home *** CD-ROM | disk | FTP | other *** search
/ PC World 2002 September / PCWorld_2002-09_cd.bin / Software / Vyzkuste / httrack / httrack-3.20RC4.exe / {app} / src / htsback.c < prev    next >
C/C++ Source or Header  |  2002-07-09  |  93KB  |  2,411 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20.  
  21. Important notes:
  22.  
  23. - We hereby ask people using this source NOT to use it in purpose of grabbing
  24. emails addresses, or collecting any other private information on persons.
  25. This would disgrace our work, and spoil the many hours we spent on it.
  26.  
  27.  
  28. Please visit our Website: http://www.httrack.com
  29. */
  30.  
  31.  
  32. /* ------------------------------------------------------------ */
  33. /* File: httrack.c subroutines:                                 */
  34. /*       backing system (multiple socket download)              */
  35. /* Author: Xavier Roche                                         */
  36. /* ------------------------------------------------------------ */
  37.  
  38. #include "htsback.h"
  39.  
  40. /* specific definitions */
  41. #include "htsbase.h"
  42. #include "htsnet.h"
  43. #include "htsthread.h"
  44. #include <stdio.h>
  45. #include <stdlib.h>
  46. #include <string.h>
  47. #include <time.h>
  48. /* END specific definitions */
  49.  
  50. //#if HTS_WIN
  51. #include "htsftp.h"
  52. #if HTS_USEZLIB
  53. #include "htszlib.h"
  54. #endif
  55. //#endif
  56.  
  57. #if HTS_WIN
  58. #ifndef __cplusplus
  59. // DOS
  60. #include <process.h>    /* _beginthread, _endthread */
  61. #endif
  62. #else
  63. #endif
  64.  
  65. #undef test_flush
  66. #define test_flush if (opt->flush) { if (opt->log) { fflush(opt->log); } if (opt->errlog) { fflush(opt->errlog);  } }
  67.  
  68. #define VT_CLREOL       "\33[K"
  69.  
  70.  
  71. // ---
  72. // routines de backing
  73. // retourne l'index d'un lien dans un tableau de backing
  74. int back_index(lien_back* back,int back_max,char* adr,char* fil,char* sav) {
  75.   int i=0;
  76.   int index=-1;
  77.   while( i<back_max ) {
  78.     if (back[i].status>=0)    // rΘception OU prΩt
  79.       if (strfield2(back[i].url_adr,adr)) {
  80.         if (strcmp(back[i].url_fil,fil)==0) {
  81.           if (index==-1)    /* first time we meet, store it */
  82.             index=i;
  83.           else if (strcmp(back[i].url_sav,sav)==0) {  /* oops, check sav too */
  84.             index=i;
  85.             return index;
  86.           }
  87.         }
  88.       }
  89.     i++;
  90.   }
  91.   return index;
  92. }
  93.  
  94. // nombre d'entrΘes libres dans le backing
  95. int back_available(lien_back* back,int back_max) {
  96.   int i;
  97.   int nb=0;
  98.   for(i=0;i<back_max;i++)
  99.     if (back[i].status==-1)     /* libre */
  100.       nb++;
  101.   return nb;
  102. }
  103.  
  104. // retourne estimation de la taille des html et fichiers stockΘs en mΘmoire
  105. LLint back_incache(lien_back* back,int back_max) {
  106.   int i;
  107.   LLint sum=0;
  108.   for(i=0;i<back_max;i++)
  109.     if (back[i].status!=-1)
  110.       if (back[i].r.adr)       // ne comptabilier que les blocs en mΘmoire
  111.         sum+=max(back[i].r.size,back[i].r.totalsize);
  112.   return sum;
  113. }
  114.  
  115. // le lien a-t-il ΘtΘ mis en backing?
  116. HTS_INLINE int back_exist(lien_back* back,int back_max,char* adr,char* fil,char* sav) {
  117.   return (back_index(back,back_max,adr,fil,sav)>=0);
  118. }
  119.  
  120. // nombre de sockets en tΓche de fond
  121. int back_nsoc(lien_back* back,int back_max) {
  122.   int n=0;
  123.   int i;
  124.   for(i=0;i<back_max;i++)
  125.     if (back[i].status>0)    // rΘception uniquement
  126.       n++;
  127.  
  128.   return n;
  129. }
  130.  
  131. // objet (lien) tΘlΘchargΘ ou transfΘrΘ depuis le cache
  132. //
  133. // fermer les paramΦtres de transfert,
  134. // et notamment vΘrifier les fichiers compressΘs (dΘcompresser), callback etc.
  135. int back_finalize(httrackp* opt,cache_back* cache,lien_back* back,int p) {
  136.   if (
  137.       (back[p].status == 0)      // ready
  138.       &&
  139.       (!back[p].testmode)        // not test mode
  140.       &&
  141.       (back[p].r.statuscode>0)   // not internal error
  142.       ) {
  143.     char* state="unknown";
  144.    
  145.     /* dΘcompression */
  146. #if HTS_USEZLIB
  147.     if ((back[p].r.compressed) && (back[p].r.adr)) {
  148.       if (back[p].r.size>0) {
  149.         //if ( (back[p].r.adr) && (back[p].r.size>0) ) {
  150.         // stats
  151.         back[p].compressed_size=back[p].r.size;
  152.         // en mΘmoire -> passage sur disque
  153.         if (!back[p].r.is_write) {
  154.           back[p].tmpfile[0]='\0';
  155.           strcpy(back[p].tmpfile,tempnam(NULL,"httrz"));
  156.           if (back[p].tmpfile[0]) {
  157.             back[p].r.out=fopen(back[p].tmpfile,"wb");
  158.             if (back[p].r.out) {
  159.               if ((back[p].r.adr) && (back[p].r.size>0)) {
  160.                 if ((INTsys)fwrite(back[p].r.adr,1,(INTsys)back[p].r.size,back[p].r.out) != back[p].r.size) {
  161.                   back[p].r.statuscode=-1;
  162.                   strcpy(back[p].r.msg,"Write error when decompressing");
  163.                 }
  164.               } else {
  165.                 back[p].tmpfile[0]='\0';
  166.                 back[p].r.statuscode=-1;
  167.                 strcpy(back[p].r.msg,"Empty compressed file");
  168.               }
  169.             } else {
  170.               back[p].tmpfile[0]='\0';
  171.               back[p].r.statuscode=-1;
  172.               strcpy(back[p].r.msg,"Open error when decompressing");
  173.             }
  174.           }
  175.         }
  176.         // fermer fichier sortie
  177.         if (back[p].r.out!=NULL) {
  178.           fclose(back[p].r.out);
  179.           back[p].r.out=NULL;
  180.         }
  181.         // dΘcompression
  182.         if (back[p].tmpfile[0] && back[p].url_sav[0]) {
  183.           LLint size;
  184.           filecreateempty(back[p].url_sav);      // filenote & co
  185.           if ((size = hts_zunpack(back[p].tmpfile,back[p].url_sav))>=0) {
  186.             back[p].r.size=back[p].r.totalsize=size;
  187.             // fichier -> mΘmoire
  188.             if (!back[p].r.is_write) {
  189.               back[p].r.adr=readfile(back[p].url_sav);
  190.               if (!back[p].r.adr) {
  191.                 back[p].r.statuscode=-1;
  192.                 strcpy(back[p].r.msg,"Read error when decompressing");
  193.               }
  194.               remove(back[p].url_sav);
  195.             }
  196.           }
  197.           remove(back[p].tmpfile);
  198.         }
  199.         // stats
  200.         HTS_STAT.total_packed+=back[p].compressed_size;
  201.         HTS_STAT.total_unpacked+=back[p].r.size;
  202.         HTS_STAT.total_packedfiles++;
  203.         // unflag
  204.       }
  205.     }
  206.     back[p].r.compressed=0;
  207. #endif
  208.     
  209.     /* Stats */
  210.     if (cache->txt) {
  211.       char flags[32];
  212.       char s[256];
  213.       time_t tt;
  214.       struct tm* A;
  215.       tt=time(NULL);
  216.       A=localtime(&tt);
  217.       strftime(s,250,"%H:%M:%S",A);
  218.       
  219.       flags[0]='\0';
  220.       /* input flags */
  221.       if (back[p].is_update)
  222.         strcat(flags, "U");   // update request
  223.       else
  224.         strcat(flags, "-");
  225.       if (back[p].range_req_size)
  226.         strcat(flags, "R");   // range request
  227.       else
  228.         strcat(flags, "-");
  229.       /* state flags */
  230.       if (back[p].r.is_file)  // direct to disk
  231.         strcat(flags, "F");
  232.       else
  233.         strcat(flags, "-");
  234.       /* output flags */
  235.       if (!back[p].r.notmodified)
  236.         strcat(flags, "M");   // modified
  237.       else
  238.         strcat(flags, "-");
  239.       if (back[p].r.is_chunk)  // chunked
  240.         strcat(flags, "C");
  241.       else
  242.         strcat(flags, "-");
  243.       if (back[p].r.compressed)
  244.         strcat(flags, "Z");   // gzip
  245.       else
  246.         strcat(flags, "-");
  247.       fprintf(cache->txt,"%s\t"LLintP"/"LLintP"\t%s\t", s, 
  248.         back[p].r.size, back[p].r.totalsize, 
  249.         flags);
  250.     }
  251.     if (back[p].r.statuscode==200) {
  252.       if (back[p].r.size>=0) {
  253.         if (strcmp(back[p].url_fil,"/robots.txt") !=0 ) {
  254.           HTS_STAT.stat_bytes+=back[p].r.size;
  255.           HTS_STAT.stat_files++;
  256.         }
  257.         if ( (!back[p].r.notmodified) && (opt->is_update) ) { 
  258.           HTS_STAT.stat_updated_files++;       // page modifiΘe
  259.           if (opt->log!=NULL) {
  260.             fspc(opt->log,"info");
  261.             if (back[p].is_update) {
  262.               fprintf(opt->log,"engine: transfer-status: link updated: %s%s -> %s"LF,back[p].url_adr,back[p].url_fil,back[p].url_sav);
  263.             } else {
  264.               fprintf(opt->log,"engine: transfer-status: link added: %s%s -> %s"LF,back[p].url_adr,back[p].url_fil,back[p].url_sav);
  265.             }
  266.             test_flush;
  267.           }
  268.           if (cache->txt) {
  269.             if (back[p].is_update) {
  270.               state="updated";
  271.             } else {
  272.               state="added";
  273.             }
  274.           }
  275.         } else {
  276.           if ( (opt->debug>0) && (opt->log!=NULL) ) {
  277.             fspc(opt->log,"info"); fprintf(opt->log,"engine: transfer-status: link recorded: %s%s -> %s"LF,back[p].url_adr,back[p].url_fil,back[p].url_sav);
  278.             test_flush;
  279.           }
  280.           if (cache->txt) {
  281.             if (opt->is_update)
  282.               state="untouched";
  283.             else
  284.               state="added";
  285.           }
  286.         }
  287.       } else {
  288.         if ( (opt->debug>0) && (opt->log!=NULL) ) {
  289.           fspc(opt->log,"info"); fprintf(opt->log,"engine: transfer-status: empty file? (%d, '%s'): %s%s"LF,back[p].r.statuscode,back[p].r.msg,back[p].url_adr,back[p].url_fil);
  290.           test_flush;
  291.         }
  292.         if (cache->txt) {
  293.           state="empty";
  294.         }
  295.       }
  296.     } else {
  297.       if ( (opt->debug>0) && (opt->log!=NULL) ) {
  298.         fspc(opt->log,"info"); fprintf(opt->log,"engine: transfer-status: link error (%d, '%s'): %s%s"LF,back[p].r.statuscode,back[p].r.msg,back[p].url_adr,back[p].url_fil);
  299.       }
  300.       if (cache->txt) {
  301.         state="error";
  302.       }
  303.     }
  304.     if (cache->txt) {
  305.       fprintf(cache->txt,
  306.         "%d\t"
  307.         "%s ('%s')\t"
  308.         "%s\t"
  309.         "%s%s\t"
  310.         "%s%s\t%s\t"
  311.         "(from %s%s)"
  312.         LF,
  313.         back[p].r.statuscode,
  314.         state, escape_check_url_addr(back[p].r.msg),
  315.         escape_check_url_addr(back[p].r.contenttype),
  316.         ((back[p].r.etag[0])?"etag:":((back[p].r.lastmodified[0])?"date:":"")), escape_check_url_addr((back[p].r.etag[0])?back[p].r.etag:(back[p].r.lastmodified)),
  317.         escape_check_url_addr(back[p].url_adr),escape_check_url_addr(back[p].url_fil),escape_check_url_addr(back[p].url_sav),
  318.         escape_check_url_addr(back[p].referer_adr),escape_check_url_addr(back[p].referer_fil)
  319.         );
  320.       if (opt->flush)
  321.         fflush(cache->txt);
  322.     }
  323.     
  324.     /* Cache */
  325.     cache_mayadd(opt,cache,&back[p].r,back[p].url_adr,back[p].url_fil,back[p].url_sav);
  326.     
  327.     // status finished callback
  328. #if HTS_ANALYSTE
  329.     hts_htmlcheck_xfrstatus(&back[p]);
  330. #endif
  331.     return 0;
  332.   }
  333.   return -1;
  334. }
  335.  
  336.  
  337. // effacer entrΘe
  338. int back_delete(lien_back* back,int p) {
  339.   if (p>=0) {    // on sait jamais..
  340.     // VΘrificateur d'intΘgritΘ
  341.     #if DEBUG_CHECKINT
  342.     _CHECKINT(&back[p],"Appel back_delete")
  343.     #endif
  344. #if HTS_DEBUG_CLOSESOCK
  345.     char info[256];
  346.     sprintf(info,"back_delete: #%d\n",p);
  347.     DEBUG_W2(info);
  348. #endif
  349.  
  350.     // LibΘrer tous les sockets, handles, buffers..
  351.     if (back[p].r.soc!=INVALID_SOCKET) {
  352. #if HTS_DEBUG_CLOSESOCK
  353.       DEBUG_W("back_delete: deletehttp\n");
  354. #endif
  355.       deletehttp(&back[p].r);
  356.       back[p].r.soc=INVALID_SOCKET;
  357.     }
  358.     
  359. #if HTS_USEOPENSSL
  360.     /* Free OpenSSL structures */
  361.     if (back[p].r.ssl_con) {
  362.       SSL_shutdown(back[p].r.ssl_con);
  363.       SSL_free(back[p].r.ssl_con);
  364.       back[p].r.ssl_con=NULL;
  365.     }
  366.     /*
  367.     if (back[p].r.ssl_soc) {
  368.       BIO_free_all(back[p].r.ssl_soc);
  369.       back[p].r.ssl_soc=NULL;
  370.     }
  371.     */
  372. #endif
  373.     
  374.     if (back[p].r.adr!=NULL) {  // reste un bloc α dΘsallouer
  375.       freet(back[p].r.adr);
  376.       back[p].r.adr=NULL;
  377.     }
  378.     if (back[p].chunk_adr!=NULL) {  // reste un bloc α dΘsallouer
  379.       freet(back[p].chunk_adr);
  380.       back[p].chunk_adr=NULL;
  381.       back[p].chunk_size=0;
  382.       back[p].is_chunk=0;
  383.     }
  384.     // if (back[p].r.is_file) {  // fermer fichier entrΘe
  385.     if (back[p].r.fp!=NULL) {
  386.       fclose(back[p].r.fp);
  387.       back[p].r.fp=NULL;
  388.     }
  389.     // }
  390.  
  391.     /* fichier de sortie */
  392.     if (back[p].r.out!=NULL) {  // fermer fichier sortie
  393.       fclose(back[p].r.out);
  394.       back[p].r.out=NULL;
  395.     }
  396.  
  397.     if (back[p].r.is_write) {     // ecriture directe
  398.       /* Θcrire date "remote" */
  399.       if (strnotempty(back[p].url_sav))          // normalement existe si on a un fichier de sortie
  400.       if (strnotempty(back[p].r.lastmodified))   // last-modified existe
  401.       if (fexist(back[p].url_sav))          // ainsi que le fichier
  402.         set_filetime_rfc822(back[p].url_sav,back[p].r.lastmodified);
  403.  
  404.       /* executer commande utilisateur aprΦs chargement du fichier */
  405.       usercommand(0,NULL,back[p].url_sav);
  406.       back[p].r.is_write=0;
  407.     }
  408.     
  409.     // Tout nettoyer
  410.     memset(&back[p], 0, sizeof(lien_back));  
  411.     back[p].r.soc=INVALID_SOCKET; back[p].r.location=back[p].location_buffer;
  412.     
  413.     // Le plus important: libΘrer le champ
  414.     back[p].status=-1;
  415.   }
  416.   return 0;
  417. }
  418.  
  419. /* Space left on backing stack */
  420. int back_stack_available(lien_back* back,int back_max) {
  421.   int p=0,n=0;
  422.   for( ; p < back_max ; p++ )
  423.     if ( back[p].status == -1 )
  424.       n++;
  425.   return n;
  426. }
  427.  
  428. // ajouter un lien en backing
  429. int back_add(lien_back* back,int back_max,httrackp* opt,cache_back* cache,char* adr,char* fil,char* save,char* referer_adr,char* referer_fil,int test,short int* pass2_ptr) {
  430.   int p=0;
  431.  
  432.   // vΘrifier cohΘrence de adr et fil (non vide!)
  433.   if (strnotempty(adr)==0) {
  434.     if ((opt->debug>1) && (opt->errlog!=NULL)) {
  435.       fspc(opt->errlog,"debug"); fprintf(opt->errlog,"error: adr is empty for back_add"LF);
  436.     }
  437.     return -1;    // erreur!
  438.   }
  439.   if (strnotempty(fil)==0) {
  440.     if ((opt->debug>1) && (opt->errlog!=NULL)) {
  441.       fspc(opt->errlog,"debug"); fprintf(opt->errlog,"error: fil is empty for back_add"LF);
  442.     }
  443.     return -1;    // erreur!
  444.   }
  445.   // FIN vΘrifier cohΘrence de adr et fil (non vide!)
  446.  
  447.   // rechercher emplacement
  448.   while((p<back_max) && back[p].status!=-1) p++;
  449.   if (back[p].status==-1) {    // ok on a de la place
  450.     back[p].send_too[0]='\0';  // Θventuels paramΦtres supplΘmentaires α transmettre au serveur
  451.  
  452.     // ne sert α rien normalement
  453.     if (back[p].r.soc!=INVALID_SOCKET) {
  454. #if HTS_DEBUG_CLOSESOCK
  455.       DEBUG_W("back_add: deletehttp\n");
  456. #endif
  457.       deletehttp(&back[p].r);
  458.     }
  459.  
  460.     // effacer r
  461.     memset(&(back[p].r), 0, sizeof(htsblk)); back[p].r.soc=INVALID_SOCKET; back[p].r.location=back[p].location_buffer;
  462.  
  463.     // crΘer entrΘe
  464.     strcpy(back[p].url_adr,adr);
  465.     strcpy(back[p].url_fil,fil);
  466.     strcpy(back[p].url_sav,save);
  467.     back[p].pass2_ptr=pass2_ptr;
  468.     // copier referer si besoin
  469.     strcpy(back[p].referer_adr,"");
  470.     strcpy(back[p].referer_fil,"");
  471.     if ((referer_adr) && (referer_fil)) {       // existe
  472.       if ((strnotempty(referer_adr)) && (strnotempty(referer_fil))) {   // non vide
  473.         if (referer_adr[0]!='!') {    // non dΘtruit
  474.           if (strcmp(referer_adr,"file://")) {      // PAS file://
  475.             if (strcmp(referer_adr,"primary")) {      // pas referer 1er lien
  476.               strcpy(back[p].referer_adr,referer_adr);
  477.               strcpy(back[p].referer_fil,referer_fil);
  478.             }
  479.           }
  480.         }
  481.       }
  482.     }
  483.     // sav ne sert α rien pour le moment
  484.     back[p].r.size=0;                   // rien n'a encore ΘtΘ chargΘ
  485.     back[p].r.soc=INVALID_SOCKET;       // pas de socket
  486.     back[p].r.adr=NULL;                 // pas de bloc de mΘmoire
  487.     back[p].r.is_write=0;               // α priori stockage en mΘmoire
  488.     back[p].maxfile_html=opt->maxfile_html;
  489.     back[p].maxfile_nonhtml=opt->maxfile_nonhtml;
  490.     back[p].testmode=test;              // mode test?
  491.     if (!opt->http10)                 // option "forcer 1.0" dΘsactivΘe
  492.       back[p].http11=1;               // autoriser http/1.1
  493.     back[p].head_request=0;
  494.     if (strcmp(back[p].url_sav,BACK_ADD_TEST)==0)    // HEAD
  495.       back[p].head_request=1;
  496.     else if (strcmp(back[p].url_sav,BACK_ADD_TEST2)==0)    // test en GET
  497.       back[p].head_request=2;       // test en get
  498.  
  499.     
  500.     /* Stop requested - abort backing */
  501.     if (opt->state.stop) {
  502.       back[p].r.statuscode=-1;        // fatal
  503.       strcpy(back[p].r.msg,"mirror stopped by user");
  504.       back[p].status=0;  // terminΘ
  505.       if ((opt->debug>0) && (opt->log!=NULL)) {
  506.         fspc(opt->log,"warning"); fprintf(opt->log,"File not added due to mirror cancel: %s%s",adr,fil); test_flush;
  507.       }            
  508.       return 0;
  509.     }
  510.  
  511.  
  512.     // tester cache
  513.     if ((strcmp(adr,"file://"))           /* pas fichier */
  514.       && ( (!test) || (cache->type==1) )   /* cache prioritaire, laisser passer en test! */
  515.       && ( (strnotempty(save)) || (strcmp(fil,"/robots.txt")==0) ) ) {  // si en test on ne doit pas utiliser le cache sinon telescopage avec le 302..
  516.       //if ((!test) && (strcmp(adr,"file://")) 
  517.       //if ((!test) && (strncmp(adr,"ftp://",6)) && (strcmp(adr,"file://")) 
  518. #if HTS_FAST_CACHE
  519.       long int hash_pos;
  520.       int hash_pos_return=0;
  521. #else
  522.       char* a=NULL;
  523. #endif
  524. #if HTS_FAST_CACHE
  525.       if (cache->hashtable) { 
  526. #else
  527.       if (cache->use) { 
  528. #endif
  529.         char buff[HTS_URLMAXSIZE*4];
  530. #if HTS_FAST_CACHE
  531.         strcpy(buff,adr); strcat(buff,fil);
  532.         hash_pos_return=inthash_read((inthash)cache->hashtable,buff,(long int*)&hash_pos);
  533. #else
  534.         buff[0]='\0'; strcat(buff,"\n"); strcat(buff,adr); strcat(buff,"\n"); strcat(buff,fil); strcat(buff,"\n");
  535.         a=strstr(cache->use,buff);
  536. #endif
  537.         
  538.         // Ok, notΘ en cache->. mais bien prΘsent dans le cache ou sur disque?
  539. #if HTS_FAST_CACHE
  540.         if (hash_pos_return) {
  541. #else
  542.         if (a) {
  543. #endif
  544.           if (!test) {      // non mode test
  545. #if HTS_FAST_CACHE
  546.             int pos=hash_pos;
  547. #else
  548.             int pos=-1;
  549.             a+=strlen(buff);
  550.             sscanf(a,"%d",&pos);    // lire position
  551. #endif
  552.             if (pos<0) {    // pas de mise en cache data, vΘrifier existence
  553.               if (fsize(antislash(save)) <= 0) {  // fichier existe pas ou est vide!
  554. #if HTS_FAST_CACHE
  555.                 hash_pos_return=0;
  556. #else
  557.                 a=NULL;    
  558. #endif
  559.                 // dΘvalider car non prΘsent sur disque dans structure originale!!!
  560.                 // sinon, le fichier est ok α priori, mais on renverra un if-modified-since pour
  561.                 // en Ωtre s√r
  562.                 if (opt->norecatch) {              // tester norecatch
  563.                   if (!fexist(antislash(save))) {  // fichier existe pas mais dΘclarΘ: on l'a effacΘ
  564.                     FILE* fp=fopen(antislash(save),"wb");
  565.                     if (fp) fclose(fp);
  566.                     if (opt->log!=NULL) {
  567.                       fspc(opt->log,"warning"); fprintf(opt->log,"File must have been erased by user, ignoring: %s%s"LF,back[p].url_adr,back[p].url_fil); test_flush;
  568.                     }
  569.                   }
  570.                 }
  571.               }
  572.             }
  573.           }
  574.         }
  575.         //
  576.       } else
  577. #if HTS_FAST_CACHE
  578.         hash_pos_return=0;
  579. #else
  580.         a=NULL;
  581. #endif
  582.  
  583.       // Existe pas en cache, ou bien pas de cache prΘsent
  584. #if HTS_FAST_CACHE
  585.       if (hash_pos_return) {  // OK existe en cache (et donnΘes aussi)!
  586. #else
  587.       if (a!=NULL) {  // OK existe en cache (et donnΘes aussi)!
  588. #endif
  589.         if (cache->type==1) {   // cache prioritaire (pas de test if-modified..)
  590.                                // dans ce cas on peut Θgalement lire des rΘponses cachΘes comme 404,302... 
  591.           // lire dans le cache
  592.           if (!test)
  593.             back[p].r=cache_read(opt,cache,adr,fil,save);
  594.           else
  595.             back[p].r=cache_read(opt,cache,adr,fil,NULL);       // charger en tΩte uniquement du cache
  596.           if (!back[p].r.location) 
  597.             back[p].r.location=back[p].location_buffer;
  598.           else {    /* recopier */
  599.             strcpy(back[p].location_buffer,back[p].r.location);
  600.             back[p].r.location=back[p].location_buffer;
  601.           }
  602.  
  603.           /* Interdiction taille par le wizard? --> dΘtruire */
  604.           if (back[p].r.statuscode != -1) {  // pas d'erreur de lecture
  605.             if (!back_checksize(opt,&back[p],0)) {
  606.               back[p].status=0;  // FINI
  607.               back[p].r.statuscode=-1;
  608.               if (!back[p].testmode)
  609.                 strcpy(back[p].r.msg,"Cached file skipped (too big)");
  610.               else
  611.                 strcpy(back[p].r.msg,"Test: Cached file skipped  (too big)");
  612.               return 0;
  613.             }
  614.           }
  615.  
  616.           if (back[p].r.statuscode != -1) {  // pas d'erreur de lecture
  617.             if ((opt->debug>0) && (opt->log!=NULL)) {
  618.               if (!test) {
  619.                 fspc(opt->log,"debug"); fprintf(opt->log,"File immediately loaded from cache: %s%s"LF,back[p].url_adr,back[p].url_fil); test_flush;
  620.               } else {
  621.                 fspc(opt->log,"debug"); fprintf(opt->log,"File immediately tested from cache: %s%s"LF,back[p].url_adr,back[p].url_fil); test_flush;
  622.               }
  623.             }
  624.             back[p].r.notmodified=1;    // fichier non modifiΘ
  625.             back[p].status=0;  // OK prΩt
  626.  
  627.             // finalize transfer
  628.             if (!test) {
  629.               if (back[p].r.statuscode>0) {
  630.                 back_finalize(opt,cache,back,p);
  631.               }
  632.             }
  633.  
  634.             return 0;
  635.           } else {  // erreur
  636.             // effacer r
  637.             memset(&(back[p].r), 0, sizeof(htsblk)); back[p].r.soc=INVALID_SOCKET; back[p].r.location=back[p].location_buffer;
  638.             // et continuer (chercher le fichier)
  639.           }
  640.           
  641.         } else if (cache->type==2) {    // si en cache, demander de tester If-Modified-Since
  642.           htsblk* r=cache_header(opt,cache,adr,fil);
  643.  
  644.           /* Interdiction taille par le wizard? */
  645.           {
  646.             LLint save_totalsize=back[p].r.totalsize;
  647.             back[p].r.totalsize=r->totalsize;
  648.             if (!back_checksize(opt,&back[p],1)) {
  649.               r=NULL;
  650.               //
  651.               back[p].status=0;  // FINI
  652.               deletehttp(&back[p].r); back[p].r.soc=INVALID_SOCKET;
  653.               if (!back[p].testmode)
  654.                 strcpy(back[p].r.msg,"File too big");
  655.               else
  656.                 strcpy(back[p].r.msg,"Test: File too big");
  657.               return 0;
  658.             }
  659.             back[p].r.totalsize=save_totalsize;
  660.           }
  661.           
  662.           if (r) {
  663.             if (r->statuscode==200) {     // uniquement des 200 (OK)
  664.               if (strnotempty(r->etag)) {  // ETag (RFC2616)
  665.                 /*
  666.                 - If both an entity tag and a Last-Modified value have been
  667.                 provided by the origin server, SHOULD use both validators in
  668.                 cache-conditional requests. This allows both HTTP/1.0 and
  669.                 HTTP/1.1 caches to respond appropriately.
  670.                 */
  671.                 if (strnotempty(r->lastmodified))
  672.                   sprintf(back[p].send_too,"If-None-Match: %s\r\nIf-Modified-Since: %s\r\n",r->etag,r->lastmodified);
  673.                 else
  674.                   sprintf(back[p].send_too,"If-None-Match: %s\r\n",r->etag);
  675.               }
  676.               else if (strnotempty(r->lastmodified))
  677.                 sprintf(back[p].send_too,"If-Modified-Since: %s\r\n",r->lastmodified);
  678.               else if (strnotempty(cache->lastmodified))
  679.                 sprintf(back[p].send_too,"If-Modified-Since: %s\r\n",cache->lastmodified);
  680.               
  681.               /* this is an update of a file */
  682.               if (strnotempty(back[p].send_too))
  683.                 back[p].is_update=1;
  684.               back[p].r.req.nocompression=1;   /* Do not compress when updating! */
  685.               
  686.             }
  687.             /* else if (strnotempty(cache->lastmodified))
  688.             sprintf(back[p].send_too,"If-Modified-Since: %s\r\n",cache->lastmodified);
  689.             */
  690.           }
  691. #if DEBUGCA
  692.           printf("..is modified test %s\n",back[p].send_too);
  693. #endif
  694.         } 
  695.         // Okay, pas trouvΘ dans le cache
  696.         // Et si le fichier existe sur disque?
  697.         // Pas dans le cache: fichier n'a pas ΘtΘ transfΘrΘ du tout, donc pas sur disque?
  698.       } else {
  699.         if (fexist(save)) {    // fichier existe? aghl!
  700.           LLint sz=fsize(save);
  701.           // Bon, lα il est possible que le fichier ait ΘtΘ partiellement transfΘrΘ
  702.           // (s'il l'avait ΘtΘ en totalitΘ il aurait ΘtΘ inscrit dans le cache ET existerait sur disque)
  703.           // PAS de If-Modified-Since, on a pas connaissance des donnΘes α la date du cache
  704.           // On demande juste les donnΘes restantes si le date est valide (206), tout sinon (200)
  705.           if ((ishtml(save) != 1) && (ishtml(back[p].url_fil)!=1)) {   // NON HTML (liens changΘs!!)
  706.             if (sz>0) {    // Fichier non vide? (question bΩte, sinon on transfert tout!)
  707.               if (strnotempty(cache->lastmodified)) {     /* pas de If-.. possible */
  708.                 /*if ( (!opt->http10) && (strnotempty(cache->lastmodified)) ) { */    /* ne pas forcer 1.0 */
  709. #if DEBUGCA
  710.                 printf("..if unmodified since %s size "LLintP"\n",cache->lastmodified,(LLint)sz);
  711. #endif
  712.                 if ((opt->debug>1) && (opt->log!=NULL)) {
  713.                   fspc(opt->log,"debug"); fprintf(opt->log,"File partially present ("LLintP" bytes): %s%s"LF,(LLint)sz,back[p].url_adr,back[p].url_fil); test_flush;
  714.                 }
  715.                 
  716.                 /* impossible - don't have etag or date
  717.                 if (strnotempty(back[p].r.etag)) {  // ETag (RFC2616)
  718.                 sprintf(back[p].send_too,"If-None-Match: %s\r\n",back[p].r.etag);
  719.                 back[p].http11=1;    // En tΩte 1.1
  720.                 } else if (strnotempty(back[p].r.lastmodified)) {
  721.                 sprintf(back[p].send_too,"If-Unmodified-Since: %s\r\n",back[p].r.lastmodified);
  722.                 back[p].http11=1;    // En tΩte 1.1
  723.                 } else 
  724.                 */
  725.                 if (strlen(cache->lastmodified)) {
  726.                   sprintf(back[p].send_too,
  727.                     "If-Unmodified-Since: %s\r\nRange: bytes="LLintP"-\r\n"
  728.                     ,cache->lastmodified,(LLint)sz);
  729.                   back[p].http11=1;    // En tΩte 1.1
  730.                   back[p].range_req_size=sz;
  731.                   back[p].r.req.range_used=1;
  732.                   back[p].r.req.nocompression=1;
  733.                 } else {
  734.                   if ((opt->debug>0) && (opt->errlog!=NULL)) {
  735.                     fspc(opt->log,"warning"); fprintf(opt->log,"Could not find timestamp for partially present file, restarting (lost "LLintP" bytes): %s%s"LF,(LLint)sz,back[p].url_adr,back[p].url_fil); test_flush;
  736.                   }
  737.                 }
  738.                 
  739.               } else { 
  740.                 if ((opt->debug>0) && (opt->errlog!=NULL)) {
  741.                   fspc(opt->errlog,"warning");
  742.                   /*
  743.                   if (opt->http10)
  744.                   fprintf(opt->errlog,"File partially present (%d bytes) retransfered due to HTTP/1.0 settings: %s%s"LF,sz,back[p].url_adr,back[p].url_fil);
  745.                   else
  746.                   */
  747.                   fprintf(opt->errlog,"File partially present ("LLintP" bytes) retransfered due to lack of cache: %s%s"LF,(LLint)sz,back[p].url_adr,back[p].url_fil); 
  748.                   test_flush;
  749.                 }
  750.                 /* Sinon requΩte normale... */
  751.                 back[p].http11=0;
  752.               }
  753.             } else if (opt->norecatch) {              // tester norecatch
  754.               filenote(save,NULL);       // ne pas purger tout de mΩme
  755.               back[p].status=0;  // OK prΩt
  756.               back[p].r.statuscode=-1;  // erreur
  757.               strcpy(back[p].r.msg,"Null-size file not recaught");
  758.               return 0;
  759.             }
  760.           } else {
  761.             if ((opt->debug>0) && (opt->errlog!=NULL)) {
  762.               fspc(opt->errlog,"warning");
  763.               fprintf(opt->errlog,"HTML file ("LLintP" bytes) retransfered due to lack of cache: %s%s"LF,(LLint)sz,back[p].url_adr,back[p].url_fil); 
  764.               test_flush;
  765.             }
  766.             /* Sinon requΩte normale... */
  767.             back[p].http11=0;
  768.           }
  769.         }
  770.       }
  771.     }
  772.  
  773.  
  774.     {
  775.       ///htsblk r;   non directement dans la structure-rΘponse!
  776.       T_SOC soc;
  777.       
  778.       // ouvrir liaison, envoyer requΦte
  779.       // ne pas traiter ou recevoir l'en tΩte immΘdiatement
  780.       memset(&(back[p].r), 0, sizeof(htsblk)); back[p].r.soc=INVALID_SOCKET; back[p].r.location=back[p].location_buffer;
  781.       // recopier proxy
  782.       memcpy(&(back[p].r.req.proxy), &opt->proxy, sizeof(opt->proxy));
  783.       // et user-agent
  784.       strcpy(back[p].r.req.user_agent,opt->user_agent);
  785.       strcpy(back[p].r.req.lang_iso,opt->lang_iso);
  786.       back[p].r.req.user_agent_send=opt->user_agent_send;
  787.       // et http11
  788.       back[p].r.req.http11=back[p].http11;
  789.       back[p].r.req.nocompression=opt->nocompression;
  790.  
  791.       // mode ftp, court-circuit!
  792.       if (strfield(back[p].url_adr,"ftp://")) {
  793.         if (back[p].testmode) {
  794.           if ((opt->debug>1) && (opt->errlog!=NULL)) {
  795.             fspc(opt->errlog,"debug"); fprintf(opt->errlog,"error: forbidden test with ftp link for back_add"LF);
  796.           }
  797.           return -1;    // erreur pas de test permis
  798.         }
  799.         if (!(back[p].r.req.proxy.active && opt->ftp_proxy)) { // connexion directe, gΘrΘe en thread
  800.           back[p].status=1000;   // connexion ftp
  801. #if USE_BEGINTHREAD
  802.           launch_ftp(&(back[p]));
  803. #else
  804.           {
  805.             char nid[32];
  806.             sprintf(nid,"htsftp%d-in_progress.lock",p);
  807.             strcpy(back[p].location_buffer,fconcat(opt->path_log,nid));
  808.           }
  809.           launch_ftp(&(back[p]),back[p].location_buffer,opt->exec);
  810. #endif
  811.           return 0;
  812.         }
  813.       }
  814. #if HTS_USEOPENSSL
  815.       else if (strfield(back[p].url_adr,"https://")) {        // let's rock
  816.         back[p].r.ssl = 1;
  817.         // back[p].r.ssl_soc = NULL;
  818.         back[p].r.ssl_con = NULL;
  819.       }
  820. #endif
  821.       
  822. #if HTS_XGETHOST
  823. #if HDEBUG
  824.       printf("back_solve..\n");
  825. #endif
  826.       back[p].status=101;    // tentative de rΘsolution du nom de host
  827.       soc=INVALID_SOCKET;    // pas encore ouverte
  828.       back_solve(&back[p]);  // prΘparer
  829.       if (host_wait(&back[p])) {  // prΩt, par ex fichier ou dispo dans dns
  830. #if HDEBUG
  831.       printf("ok, dns cache ready..\n");
  832. #endif
  833.         soc=http_xfopen(0,0,0,back[p].send_too,adr,fil,&(back[p].r));
  834.         if (soc==INVALID_SOCKET) {
  835.           back[p].status=0;  // fini, erreur
  836.         }
  837.       }
  838. //
  839. #else
  840. //
  841. #if CNXDEBUG
  842.       printf("XFopen..\n");
  843. #endif
  844.  
  845.       if (strnotempty(back[p].send_too))    // envoyer un if-modified-since
  846. #if HTS_XCONN
  847.       soc=http_xfopen(0,0,0,back[p].send_too,adr,fil,&(back[p].r));
  848. #else
  849.       soc=http_xfopen(0,0,1,back[p].send_too,adr,fil,&(back[p].r));
  850. #endif
  851.       else
  852. #if HTS_XCONN
  853.         soc=http_xfopen(test,0,0,NULL,adr,fil,&(back[p].r));
  854. #else
  855.       soc=http_xfopen(test,0,1,NULL,adr,fil,&(back[p].r));
  856. #endif
  857. #endif
  858.       if (opt->timeout>0) {    // gestion du opt->timeout
  859.         back[p].timeout=opt->timeout;
  860.         back[p].timeout_refresh=time_local();
  861.       } else {
  862.         back[p].timeout=-1;    // pas de gestion (default)
  863.       }
  864.       
  865.       if (opt->rateout>0) {    // gestion d'un taux minimum de transfert tolΘrΘ
  866.         back[p].rateout=opt->rateout;
  867.         back[p].rateout_time=time_local();
  868.       } else {
  869.         back[p].rateout=-1;    // pas de gestion (default)
  870.       }
  871.  
  872.       // Note: on charge les code-page erreurs (erreur 404, etc) dans le cas o∙ cela est
  873.       // rattrapable (exemple: 301,302 moved xxx -> refresh sur la page!)
  874.       //if ((back[p].statuscode!=200) || (soc<0)) { // ERREUR HTTP/autre
  875.  
  876. #if CNXDEBUG
  877. printf("Xfopen ok, poll..\n");
  878. #endif
  879.  
  880. #if HTS_XGETHOST
  881.     if (soc!=INVALID_SOCKET)
  882.       if (back[p].status==101) {  // pas d'erreur
  883.         if (!back[p].r.is_file)
  884.           back[p].status=100;   // connexion en cours
  885.         else
  886.           back[p].status=1;     // fichier
  887.       }
  888.  
  889. #else
  890.       if (soc==INVALID_SOCKET) { // erreur socket
  891.         back[p].status=0;    // FINI
  892.         //if (back[p].soc!=INVALID_SOCKET) deletehttp(back[p].soc);
  893.         back[p].r.soc=INVALID_SOCKET;
  894.       } else {
  895.         if (!back[p].r.is_file)
  896. #if HTS_XCONN
  897.           back[p].status=100;   // connexion en cours
  898. #else
  899.           back[p].status=99;    // chargement en tΩte en cours
  900. #endif
  901.         else
  902.           back[p].status=1;     // chargement fichier
  903. #if BDEBUG==1
  904.         printf("..loading header\n");
  905. #endif
  906.       }
  907. #endif
  908.       
  909.     }
  910.  
  911.  
  912.     // note: si il y a erreur (404,etc) status=2 (terminΘ/Θchec) mais
  913.     // le lien est considΘrΘ comme traitΘ
  914.     //if (back[p].soc<0)  // erreur
  915.     //  return -1;
  916.  
  917.     return 0;
  918.   } else {
  919.     if ((opt->debug>1) && (opt->errlog!=NULL)) {
  920.       fspc(opt->errlog,"debug"); fprintf(opt->errlog,"error: no space left in stack for back_add"LF);
  921.     }
  922.     return -1;    // plus de place
  923.   }
  924. }
  925.  
  926.  
  927.  
  928. #if HTS_XGETHOST
  929. #if USE_BEGINTHREAD
  930. // lancement multithread du robot
  931. PTHREAD_TYPE Hostlookup(void* iadr_p) {
  932.   char iadr[256];
  933.   t_dnscache* cache=_hts_cache();  // adresse du cache
  934.   t_hostent* hp;
  935.   int error_found=0;
  936.  
  937.   // recopier (aprΦs id:pass)
  938. #if DEBUGDNS 
  939.   printf("resolv in background: %s\n",jump_identification(iadr_p));
  940. #endif
  941.   strcpy(iadr,jump_identification(iadr_p));
  942.   // couper Θventuel :
  943.   {
  944.     char *a;
  945.     if ( (a=jump_toport(iadr)) )
  946.       *a='\0';          // get rid of it
  947.   }
  948.   freet(iadr_p);
  949.  
  950.   // attendre que le cache dns soit prΩt
  951.   while(_hts_lockdns(-1));  // attendre libΘration
  952.   _hts_lockdns(1);          // locker
  953.   while(cache->n) {
  954.     if (strcmp(cache->iadr,iadr)==0) {
  955.       error_found=1;
  956.     }
  957.     cache=cache->n;    // calculer queue
  958.   }
  959.   if (strcmp(cache->iadr,iadr)==0) {
  960.     error_found=1;
  961.   }
  962.  
  963.   if (!error_found) {
  964.     // en gros copie de hts_gethostbyname sans le return
  965.     cache->n=(t_dnscache*) calloct(1,sizeof(t_dnscache));
  966.     if (cache->n!=NULL) {
  967.       t_fullhostent fullhostent_buffer;
  968.       strcpy(cache->n->iadr,iadr);
  969.       cache->n->host_length=0;        /* pour le moment rien */
  970.       cache->n->n=NULL;
  971.       _hts_lockdns(0);          // dΘlocker
  972.       
  973.       /* resolve */
  974. #if DEBUGDNS 
  975.       printf("gethostbyname() in progress for %s\n",iadr);
  976. #endif
  977.       cache->n->host_length=-1;
  978.       memset(cache->n->host_addr, 0, sizeof(cache->n->host_addr));
  979.       hp=vxgethostbyname(iadr, &fullhostent_buffer);
  980.       if (hp!=NULL) {
  981.         memcpy(cache->n->host_addr, hp->h_addr, hp->h_length);
  982.         cache->n->host_length = hp->h_length;
  983.       }
  984.     } else 
  985.     _hts_lockdns(0);          // dΘlocker
  986.   } else {
  987. #if DEBUGDNS 
  988.     printf("aborting resolv for %s (found)\n",iadr);
  989. #endif
  990.     _hts_lockdns(0);          // dΘlocker
  991.   }
  992.   // fin de copie de hts_gethostbyname
  993.  
  994. #if DEBUGDNS 
  995.   printf("quitting resolv for %s (result: %d)\n",iadr,(cache->n!=NULL)?cache->n->host_length:(-999));
  996. #endif
  997.  
  998.   return PTHREAD_RETURN;     /* _endthread implied  */
  999. }
  1000. #endif
  1001.  
  1002. // attendre que le host (ou celui du proxy) ait ΘtΘ rΘsolu
  1003. // si c'est un fichier, la rΘsolution est immΘdiate
  1004. // idem pour ftp://
  1005. void back_solve(lien_back* back) {
  1006.   if ((!strfield(back->url_adr,"file://")) && (!strfield(back->url_adr,"ftp://"))) {
  1007.   //## if (back->url_adr[0]!=lOCAL_CHAR) {  // qq chose α prΘparer
  1008.     char* a;
  1009.     if (!(back->r.req.proxy.active))
  1010.       a=back->url_adr;
  1011.     else
  1012.       a=back->r.req.proxy.name;
  1013.     a = jump_protocol(a);
  1014.     if (!hts_dnstest(a)) {   // non encore testΘ!..
  1015.       // inscire en thread
  1016. #if HTS_WIN
  1017.       // Windows
  1018. #if USE_BEGINTHREAD
  1019.       {
  1020.         char* p = calloct(strlen(a)+2,1);
  1021.         if (p) {
  1022.           strcpy(p,a);
  1023.           _beginthread( Hostlookup , 0, p );
  1024.         }
  1025.       }
  1026. #else
  1027.       /*t_hostent* h=*/
  1028.       /*hts_gethostbyname(a);*/  // calcul
  1029. #endif
  1030. #else
  1031. #if USE_BEGINTHREAD
  1032.         char* p = calloct(strlen(a)+2,1);
  1033.         if (p) {
  1034.           strcpy(p,a);
  1035.           _beginthread( Hostlookup , 0, p );
  1036.         }
  1037. #else
  1038.       // Sous Unix, le gethostbyname() est bloquant..
  1039.       /*t_hostent* h=*/
  1040.       /*hts_gethostbyname(a);*/  // calcul
  1041. #endif
  1042. #endif
  1043.     }
  1044.   }
  1045. }
  1046.  
  1047. // dΘtermine si le host a pu Ωtre rΘsolu
  1048. int host_wait(lien_back* back) {
  1049.   if ((!strfield(back->url_adr,"file://")) && (!strfield(back->url_adr,"ftp://"))) {
  1050.   //## if (back->url_adr[0]!=lOCAL_CHAR) {
  1051.     if (!(back->r.req.proxy.active)) {
  1052.       return (hts_dnstest(back->url_adr));
  1053.     } else {
  1054.       return (hts_dnstest(back->r.req.proxy.name));      
  1055.     }
  1056.   } else return 1;    // prΩt, fichier local
  1057. }
  1058. #endif
  1059.  
  1060.  
  1061. // Θlimine les fichiers non html en backing (anticipation)
  1062. // cleanup non-html files in backing to save backing space
  1063. // and allow faster "save in cache" operation
  1064. void back_clean(httrackp* opt,cache_back* cache,lien_back* back,int back_max) {
  1065.   int i;
  1066.   for(i=0;i<back_max;i++) {
  1067.     if (back[i].status == 0) {                                   // ready
  1068.       if (!back[i].testmode) {                                   // not test mode
  1069.         if (strnotempty(back[i].url_sav)) {                      // filename exists
  1070.           if (back[i].r.is_write) {                              // not in memory (on disk, ready)
  1071.             if (back[i].r.size>0) {                              // size>0
  1072.               if (back[i].r.statuscode==200) {                   // HTTP "OK"
  1073.                 if (!is_hypertext_mime(back[i].r.contenttype)) { // not HTML/hypertext
  1074.                   if (!may_be_hypertext_mime(back[i].r.contenttype)) { // may NOT be parseable mime type
  1075.                     if (back[i].pass2_ptr) {
  1076.                       // finalize
  1077.                       // // back_finalize(opt,cache,back,i);
  1078.                       // stats
  1079.                       //HTS_STAT.stat_bytes+=back[i].r.size;
  1080.                       //HTS_STAT.stat_files++;
  1081.                       //if ( (!back[i].r.notmodified) && (opt->is_update) ) { 
  1082.                       //  HTS_STAT.stat_updated_files++;       // page modifiΘe
  1083.                       //}
  1084.                       //cache_mayadd(opt,cache,&back[i].r,back[i].url_adr,back[i].url_fil,back[i].url_sav);
  1085.                       *back[i].pass2_ptr=-1;  // Done!
  1086.                       back_delete(back,i);    // Delete backing entry
  1087.                       if ((opt->debug>0) && (opt->log!=NULL)) {
  1088.                         fspc(opt->log,"info"); fprintf(opt->log,"File successfully written in background: %s"LF,back[i].url_sav); test_flush;
  1089.                       }
  1090.                     }
  1091.                   }
  1092.                 }
  1093.               }
  1094.             }
  1095.           }
  1096.         }
  1097.       }
  1098.     }
  1099.   }            
  1100. }
  1101.  
  1102.  
  1103. // attente (gestion des buffers des sockets)
  1104. void back_wait(lien_back* back,int back_max,httrackp* opt,cache_back* cache,TStamp stat_timestart) {
  1105.   int i;
  1106.   T_SOC nfds=INVALID_SOCKET;
  1107.   fd_set fds,fds_c,fds_e;     // fds pour lecture, connect (write), et erreur
  1108.   int nsockets;     // nbre sockets
  1109.   LLint max_read_bytes;  // max bytes read per sockets
  1110.   struct timeval tv;
  1111.   int do_wait=0;
  1112.   int gestion_timeout=0;
  1113.   int busy_recv=0;     // pas de donnΘes pour le moment   
  1114.   int busy_state=0;    // pas de connexions
  1115.   int max_loop;  // nombre de boucles max α parcourir..
  1116. #if HTS_ANALYSTE
  1117.   int max_loop_chk=0;
  1118. #endif
  1119.  
  1120.  
  1121.   // max. number of loops
  1122.   max_loop=8;
  1123.  
  1124. #if 1
  1125.   // Cleanup the stack to save space!
  1126.   back_clean(opt,cache,back,back_max);
  1127. #endif
  1128.  
  1129.   // recevoir tant qu'il y a des donnΘes (avec un maximum de max_loop boucles)
  1130.   do_wait=0;
  1131.   gestion_timeout=0;
  1132.   do {
  1133.     int max_c;
  1134.     busy_state=busy_recv=0;
  1135.  
  1136. #if 0
  1137.     check_rate(stat_timestart,opt->maxrate);    // vΘrifier taux de transfert
  1138. #endif
  1139.     // inscrire les sockets actuelles, et rechercher l'ID la plus ΘlevΘe
  1140.     FD_ZERO(&fds);
  1141.     FD_ZERO(&fds_c);
  1142.     FD_ZERO(&fds_e);
  1143.     nsockets=0;
  1144.     max_read_bytes=TAILLE_BUFFER;     // maximum bytes that can be read
  1145.     nfds=INVALID_SOCKET;
  1146.  
  1147.     max_c=1;
  1148.     for(i=0;i<back_max;i++) {
  1149.  
  1150.       // en cas de gestion du connect prΘemptif
  1151. #if HTS_XCONN
  1152.       if (back[i].status==100) {      // connexion
  1153.         do_wait=1;
  1154.  
  1155.         // noter socket write
  1156.         FD_SET(back[i].r.soc,&fds_c);
  1157.         
  1158.         // noter socket erreur
  1159.         FD_SET(back[i].r.soc,&fds_e);
  1160.  
  1161.         // calculer max
  1162.         if (max_c) {
  1163.           max_c=0;
  1164.           nfds=back[i].r.soc;
  1165.         } else if (back[i].r.soc>nfds) {
  1166.           // ID socket la plus ΘlevΘe
  1167.           nfds=back[i].r.soc;
  1168.         }
  1169.         
  1170.       } else
  1171. #endif
  1172. #if HTS_XGETHOST
  1173.       if (back[i].status==101) {      // attente
  1174.         // rien α faire..
  1175.       } else
  1176. #endif
  1177.       // poll pour la lecture sur les sockets
  1178.       if ((back[i].status>0) && (back[i].status<100)) {  // en rΘception http
  1179.             
  1180. #if BDEBUG==1
  1181.         //printf("....socket in progress: %d\n",back[i].r.soc);
  1182. #endif
  1183.         // non local et non ftp
  1184.         if (!back[i].r.is_file) {
  1185.         //## if (back[i].url_adr[0]!=lOCAL_CHAR) {
  1186.           
  1187.           // vΘrification de sΘcuritΘ
  1188.           if (back[i].r.soc!=INVALID_SOCKET) {  // hey, you never know..
  1189.             do_wait=1;
  1190.             
  1191.             // noter socket read
  1192.             FD_SET(back[i].r.soc,&fds);
  1193.             
  1194.             // noter socket error
  1195.             FD_SET(back[i].r.soc,&fds_e);
  1196.             
  1197.             // incrΘmenter nombre de sockets
  1198.             nsockets++;
  1199.  
  1200.             // calculer max
  1201.             if (max_c) {
  1202.               max_c=0;
  1203.               nfds=back[i].r.soc;
  1204.             } else if (back[i].r.soc>nfds) {
  1205.               // ID socket la plus ΘlevΘe
  1206.               nfds=back[i].r.soc;
  1207.             }
  1208.           } else {
  1209.             back[i].r.statuscode=-4;
  1210.             if (back[i].status==100)
  1211.               strcpy(back[i].r.msg,"Connect Error");
  1212.             else
  1213.               strcpy(back[i].r.msg,"Receive Error");
  1214.             back[i].status=0;  // terminΘ
  1215.             if ((opt->debug>0) && (opt->log!=NULL)) {
  1216.               fspc(opt->log,"warning"); fprintf(opt->log,"Unexpected socket error during pre-loop"LF); test_flush;
  1217.             }            
  1218.           }
  1219. #if WIDE_DEBUG
  1220.           else {
  1221.             DEBUG_W("PANIC!!! Socket is invalid in a poll test!\n");
  1222.           }
  1223. #endif
  1224.           
  1225.         }
  1226.         
  1227.       }
  1228.     }    
  1229.     nfds++;
  1230.     
  1231.     if (do_wait) {  // attendre
  1232.       // temps d'attente max: 2.5 seconde
  1233.       tv.tv_sec=HTS_SOCK_SEC;
  1234.       tv.tv_usec=HTS_SOCK_MS;
  1235.       
  1236. #if BDEBUG==1
  1237.       printf("..select\n");
  1238. #endif
  1239.       
  1240.       // poller les sockets-attention au noyau sous Unix..
  1241. #if HTS_WIDE_DEBUG    
  1242.       DEBUG_W("select\n");
  1243. #endif
  1244.       select(nfds,&fds,&fds_c,&fds_e,&tv);
  1245. #if HTS_WIDE_DEBUG    
  1246.       DEBUG_W("select done\n");
  1247. #endif      
  1248.     }
  1249.     
  1250.     // maximum data which can be received for a socket, if limited
  1251.     if (nsockets) {
  1252.       if (opt->maxrate>0) {
  1253.         max_read_bytes = ( check_downloadable_bytes(opt->maxrate) / nsockets );
  1254.       }
  1255.     }
  1256.     if (!max_read_bytes)
  1257.       busy_recv=0;
  1258.     
  1259.     // recevoir les donnΘes arrivΘes
  1260.     for(i=0;i<back_max;i++) {
  1261.       
  1262.       if (back[i].status>0) {
  1263.         if (!back[i].r.is_file) {  // not file..
  1264.           if (back[i].r.soc!=INVALID_SOCKET) {  // hey, you never know..
  1265.             int err=FD_ISSET(back[i].r.soc,&fds_e);
  1266.             if (err) {
  1267.               if (back[i].r.soc!=INVALID_SOCKET) {
  1268. #if HTS_DEBUG_CLOSESOCK
  1269.                 DEBUG_W("back_wait: deletehttp\n");
  1270. #endif
  1271.                 deletehttp(&back[i].r);
  1272.               }
  1273.               back[i].r.soc=INVALID_SOCKET;
  1274.               back[i].r.statuscode=-4;
  1275.               if (back[i].status==100)
  1276.                 strcpy(back[i].r.msg,"Connect Error");
  1277.               else
  1278.                 strcpy(back[i].r.msg,"Receive Error");
  1279.               back[i].status=0;  // terminΘ
  1280.             }
  1281.           }
  1282.         }
  1283.       }
  1284.       
  1285.       // ---- FLAG WRITE MIS A UN?: POUR LE CONNECT
  1286.       if (back[i].status==100) {   // attendre connect
  1287.         int dispo=0;
  1288.         // vΘrifier l'existance de timeout-check
  1289.         if (!gestion_timeout)
  1290.           if (back[i].timeout>0)
  1291.             gestion_timeout=1;
  1292.           
  1293.           // connectΘ?
  1294.           dispo=FD_ISSET(back[i].r.soc,&fds_c);
  1295.           if (dispo) {    // ok connected!!
  1296.             busy_state=1;
  1297.             
  1298. #if HTS_USEOPENSSL
  1299.             /* SSL mode */
  1300.             if (back[i].r.ssl) {
  1301.               // handshake not yet launched
  1302.               if (!back[i].r.ssl_con) {
  1303.                 SSL_CTX_set_options(openssl_ctx, SSL_OP_ALL);
  1304.                 // new session
  1305.                 back[i].r.ssl_con = SSL_new(openssl_ctx);
  1306.                 if (back[i].r.ssl_con) {
  1307.                   SSL_clear(back[i].r.ssl_con);
  1308.                   if (SSL_set_fd(back[i].r.ssl_con, back[i].r.soc) == 1) {
  1309.                     SSL_set_connect_state(back[i].r.ssl_con);
  1310.                     back[i].status = 102;         /* handshake wait */
  1311.                   } else
  1312.                     back[i].r.statuscode=-6;
  1313.                 } else
  1314.                   back[i].r.statuscode=-6;
  1315.               }
  1316.               /* Error */
  1317.               if (back[i].r.statuscode == -6) {
  1318.                 strcpy(back[i].r.msg, "bad SSL/TLS handshake");
  1319.                 deletehttp(&back[i].r);
  1320.                 back[i].r.soc=INVALID_SOCKET;
  1321.                 back[i].r.statuscode=-5;
  1322.                 back[i].status=0;
  1323.               }
  1324.             }
  1325.             
  1326. #endif
  1327.  
  1328. #if BDEBUG==1
  1329.           printf("..connect ok on socket %d\n",back[i].r.soc);
  1330. #endif
  1331.           
  1332.           if ((back[i].r.soc != INVALID_SOCKET) && (back[i].status==100)) {
  1333.             /* limit nb. connections/seconds to avoid server overload */
  1334.             if (opt->maxconn>0) {
  1335.               Sleep(1000/opt->maxconn);
  1336.             }
  1337.             
  1338.             if (back[i].timeout>0) {    // refresh timeout si besoin est
  1339.               back[i].timeout_refresh=time_local();
  1340.             }
  1341.             if (back[i].rateout>0) {    // le taux de transfert de base sur le dΘbut de la connexion
  1342.               back[i].rateout_time=time_local();
  1343.             }
  1344.             // envoyer header
  1345.             //if (strcmp(back[i].url_sav,BACK_ADD_TEST)!=0)    // vrai get
  1346.             if (!back[i].head_request)
  1347.               http_sendhead(opt->cookie,0,back[i].send_too,back[i].url_adr,back[i].url_fil,back[i].referer_adr,back[i].referer_fil,&back[i].r);         
  1348.             else if (back[i].head_request==2)  // test en GET!
  1349.               http_sendhead(opt->cookie,0,back[i].send_too,back[i].url_adr,back[i].url_fil,back[i].referer_adr,back[i].referer_fil,&back[i].r);         
  1350.             else        // test!
  1351.               http_sendhead(opt->cookie,1,back[i].send_too,back[i].url_adr,back[i].url_fil,back[i].referer_adr,back[i].referer_fil,&back[i].r);         
  1352.             back[i].status=99;  // attendre en tΩte maintenant
  1353.           }
  1354.         }
  1355.         
  1356.         // attente gethostbyname
  1357.       }
  1358. #if HTS_USEOPENSSL
  1359.       else if (back[i].status==102) {   // wait for SSL handshake
  1360.         /* SSL mode */
  1361.         if (back[i].r.ssl) {
  1362.           int conn_code;
  1363.           if ((conn_code = SSL_connect(back[i].r.ssl_con)) <= 0) {
  1364.             /* non blocking I/O, will retry */
  1365.             int err_code = SSL_get_error(back[i].r.ssl_con, conn_code);
  1366.             if (
  1367.               (err_code != SSL_ERROR_WANT_READ)
  1368.               &&
  1369.               (err_code != SSL_ERROR_WANT_WRITE)
  1370.               ) {
  1371.               char tmp[256];
  1372.               tmp[0]='\0';
  1373.               ERR_error_string(err_code, tmp);
  1374.               back[i].r.msg[0]='\0';
  1375.               strncat(back[i].r.msg, tmp, sizeof(back[i].r.msg) - 2);
  1376.               if (!strnotempty(back[i].r.msg)) {
  1377.                 sprintf(back[i].r.msg, "SSL/TLS error %d", err_code);
  1378.               }
  1379.               deletehttp(&back[i].r);
  1380.               back[i].r.soc=INVALID_SOCKET;
  1381.               back[i].r.statuscode=-5;
  1382.               back[i].status=0;
  1383.             }
  1384.           } else {        /* got it! */
  1385.             back[i].status=100;       // back to waitconnect
  1386.           }
  1387.         } else {
  1388.           strcpy(back[i].r.msg, "unexpected SSL/TLS error");
  1389.           deletehttp(&back[i].r);
  1390.           back[i].r.soc=INVALID_SOCKET;
  1391.           back[i].r.statuscode=-5;
  1392.           back[i].status=0;
  1393.         }
  1394.         
  1395.       }
  1396. #endif
  1397. #if HTS_XGETHOST
  1398.       else if (back[i].status==101) {  // attendre gethostbyname
  1399. #if DEBUGDNS 
  1400.         //printf("status 101 for %s\n",back[i].url_adr);
  1401. #endif
  1402.  
  1403.         if (!gestion_timeout)
  1404.           if (back[i].timeout>0)
  1405.             gestion_timeout=1;
  1406.  
  1407.         if (host_wait(&back[i])) {    // prΩt
  1408.           back[i].status=100;        // attente connexion
  1409.           if (back[i].timeout>0) {    // refresh timeout si besoin est
  1410.             back[i].timeout_refresh=time_local();
  1411.           }
  1412.           if (back[i].rateout>0) {    // le taux de transfert de base sur le dΘbut de la connexion
  1413.             back[i].rateout_time=time_local();
  1414.           }
  1415.  
  1416.           back[i].r.soc=http_xfopen(0,0,0,back[i].send_too,back[i].url_adr,back[i].url_fil,&(back[i].r));
  1417.           if (back[i].r.soc==INVALID_SOCKET) {
  1418.             back[i].status=0;  // fini, erreur
  1419.             if (back[i].r.soc!=INVALID_SOCKET) {
  1420. #if HTS_DEBUG_CLOSESOCK
  1421.               DEBUG_W("back_wait(2): deletehttp\n");
  1422. #endif
  1423.               deletehttp(&back[i].r);
  1424.             }
  1425.             back[i].r.soc=INVALID_SOCKET;
  1426.             back[i].r.statuscode=-5;
  1427.             if (strnotempty(back[i].r.msg)==0) 
  1428.               strcpy(back[i].r.msg,"Unable to resolve host name");
  1429.           }
  1430.         }
  1431.         
  1432.  
  1433.       // ---- FLAG READ MIS A UN?: POUR LA RECEPTION
  1434.       }
  1435. #endif
  1436. #if USE_BEGINTHREAD
  1437.       // ..rien α faire, c'est magic les threads
  1438. #else
  1439.       else if (back[i].status==1000) {  // en rΘception ftp
  1440.         if (!fexist(back[i].location_buffer)) {    // terminΘ
  1441.           FILE* fp;
  1442.           fp=fopen(fconcat(back[i].location_buffer,".ok"),"rb");
  1443.           if (fp) {
  1444.             int j=0;
  1445.             fscanf(fp,"%d ",&(back[i].r.statuscode));
  1446.             while(!feof(fp)) {
  1447.               int c = fgetc(fp);
  1448.               if (c!=EOF)
  1449.                 back[i].r.msg[j++]=c;
  1450.             }
  1451.             back[i].r.msg[j++]='\0';
  1452.             fclose(fp);
  1453.             remove(fconcat(back[i].location_buffer,".ok"));
  1454.             strcpy(fconcat(back[i].location_buffer,".ok"),"");
  1455.           } else {
  1456.             strcpy(back[i].r.msg,"Unknown ftp result, check if file is ok");
  1457.             back[i].r.statuscode=-1;
  1458.           }
  1459.           back[i].status=0;
  1460.           // finalize transfer
  1461.           if (back[i].r.statuscode>0) {
  1462.             back_finalize(opt,cache,back,i);
  1463.           }
  1464.         }
  1465.       }
  1466. #endif
  1467.       else if ((back[i].status>0) && (back[i].status<1000)) {  // en rΘception http
  1468.         int dispo=0;
  1469.         
  1470.         // vΘrifier l'existance de timeout-check
  1471.         if (!gestion_timeout)
  1472.           if (back[i].timeout>0)
  1473.             gestion_timeout=1;
  1474.           
  1475.           // donnΘes dispo?
  1476.           //## if (back[i].url_adr[0]!=lOCAL_CHAR)
  1477.           if (!back[i].r.is_file) {
  1478.             dispo=FD_ISSET(back[i].r.soc,&fds);
  1479.           }
  1480.           else
  1481.             dispo=1;
  1482.  
  1483.           // Check transfer rate!
  1484.           if (!max_read_bytes)
  1485.             dispo=0;                // limit transfer rate
  1486.           
  1487.           if (dispo) {    // donnΘes dispo
  1488.             LLint retour_fread;
  1489.             busy_recv=1;    // on rΘcupΦre encore
  1490. #if BDEBUG==1
  1491.             printf("..data available on socket %d\n",back[i].r.soc);
  1492. #endif
  1493.  
  1494.             
  1495.             // range size hack old location
  1496.  
  1497. #if HTS_DIRECTDISK
  1498.             // Court-circuit:
  1499.             // Peut-on stocker le fichier directement sur disque?
  1500.             // Ahh que ca serait vachement mieux et que ahh que la mΘmoire vous dit merci!
  1501.             if (back[i].status) {
  1502.               if (back[i].r.is_write==0) {  // mode mΘmoire
  1503.                 if (back[i].r.adr==NULL) {  // rien n'a ΘtΘ Θcrit
  1504.                   if (!back[i].testmode) {  // pas mode test
  1505.                     if (strnotempty(back[i].url_sav)) {
  1506.                       if (strcmp(back[i].url_fil,"/robots.txt")) {
  1507.                         if (back[i].r.statuscode==200) {  // 'OK'
  1508.                           if (!is_hypertext_mime(back[i].r.contenttype)) {    // pas HTML
  1509.                             if (opt->getmode&2) {    // on peut ecrire des non html
  1510.                               back[i].r.is_write=1;    // Θcrire
  1511.                               if (back[i].r.compressed
  1512.                                 &&
  1513.                                 (strfield(get_ext(back[i].url_sav),"gz") == 0)
  1514.                                 ) {
  1515.                                 back[i].tmpfile[0]='\0';
  1516.                                 strcpy(back[i].tmpfile,tempnam(NULL,"httrZ"));
  1517.                                 if (back[i].tmpfile[0])
  1518.                                   back[i].r.out=fopen(back[i].tmpfile,"wb");
  1519.                               } else {
  1520.                                 back[i].r.compressed=0;
  1521.                                 back[i].r.out=filecreate(back[i].url_sav);
  1522.                               }
  1523. #if HDEBUG
  1524.                               printf("direct-disk: %s\n",back[i].url_sav);
  1525. #endif
  1526.                               if ((opt->debug>1) && (opt->log!=NULL)) {
  1527.                                 fspc(opt->log,"debug"); fprintf(opt->log,"File received from net to disk: %s%s"LF,back[i].url_adr,back[i].url_fil); test_flush;
  1528.                               }
  1529.                               
  1530.                               if (back[i].r.out==NULL) {
  1531.                                 if (opt->errlog) {
  1532.                                   fspc(opt->errlog,"error");
  1533.                                   fprintf(opt->errlog,"Unable to save file %s"LF,back[i].url_sav);
  1534.                                   test_flush;
  1535.                                 }
  1536.                                 back[i].r.is_write=0;    // erreur, abandonner
  1537. #if HDEBUG
  1538.                                 printf("..error!\n");
  1539. #endif
  1540.                               }
  1541. #if HTS_WIN==0
  1542.                               else chmod(back[i].url_sav,HTS_ACCESS_FILE);      
  1543. #endif          
  1544.                             } else {  // on coupe tout!
  1545.                               if ((opt->debug>1) && (opt->log!=NULL)) {
  1546.                                 fspc(opt->log,"debug"); fprintf(opt->log,"File cancelled (non HTML): %s%s"LF,back[i].url_adr,back[i].url_fil); test_flush;
  1547.                               }
  1548.                               back[i].status=0;  // terminΘ
  1549.                               if (!back[i].testmode)
  1550.                                 back[i].r.statuscode=-10;    // EUHH CANCEL
  1551.                               else
  1552.                                 back[i].r.statuscode=-10;    // "TEST OK"
  1553.                               if (back[i].r.soc!=INVALID_SOCKET) {
  1554. #if HTS_DEBUG_CLOSESOCK
  1555.                                 DEBUG_W("back_wait(3): deletehttp\n");
  1556. #endif
  1557.                                 deletehttp(&back[i].r);
  1558.                               }
  1559.                               back[i].r.soc=INVALID_SOCKET;
  1560.                             }
  1561.                           }
  1562.                         }
  1563.                       }
  1564.                     }
  1565.                   }
  1566.                 }
  1567.               }
  1568.             }
  1569. #endif              
  1570.  
  1571.             // rΘception de donnΘes depuis socket ou fichier
  1572.             if (back[i].status) {
  1573.               if (back[i].status==99)  // recevoir par bloc de lignes
  1574.                 retour_fread=http_xfread1(&(back[i].r),0);
  1575.               else if (back[i].status==98) { // recevoir longueur chunk en hexa caractΦre par caractΦre
  1576.                 // backuper pour lire dans le buffer chunk
  1577.                 htsblk r;
  1578.                 memcpy(&r, &(back[i].r), sizeof(htsblk));
  1579.                 back[i].r.is_write=0;                   // mΘmoire
  1580.                 back[i].r.adr=back[i].chunk_adr;        // adresse
  1581.                 back[i].r.size=back[i].chunk_size;      // taille taille chunk
  1582.                 back[i].r.totalsize=-1;                 // total inconnu
  1583.                 back[i].r.out=NULL;
  1584.                 back[i].r.is_file=0;
  1585.                 //
  1586.                 // ligne par ligne
  1587.                 retour_fread=http_xfread1(&(back[i].r),-1);
  1588.                 // modifier et restaurer
  1589.                 back[i].chunk_adr=back[i].r.adr;        // adresse
  1590.                 back[i].chunk_size=back[i].r.size;      // taille taille chunk
  1591.                 memcpy(&(back[i].r), &r, sizeof(htsblk));    // restaurer vΘritable r
  1592.               }
  1593.               else if (back[i].is_chunk) {         // attention chunk, limiter taille α lire
  1594. #if CHUNKDEBUG==1
  1595.                 printf("read %d bytes\n",(int)min(back[i].r.totalsize-back[i].r.size,max_read_bytes));
  1596. #endif
  1597.                 retour_fread=(int) http_xfread1(&(back[i].r),(int) min(back[i].r.totalsize-back[i].r.size,max_read_bytes));
  1598.               } else              
  1599.                 retour_fread=(int) http_xfread1(&(back[i].r),(int) max_read_bytes);
  1600.                 // retour_fread=http_fread1(&(back[i].r));
  1601.             } else
  1602.               retour_fread=-1;                    // interruption ou annulation interne (peut ne pas Ωtre une erreur)
  1603.             
  1604.             // Si rΘception chunk, tester si on est pas α la fin!
  1605.             if (back[i].status==1) {
  1606.               if (back[i].is_chunk) {     // attendre prochain chunk
  1607.                 if (back[i].r.size==back[i].r.totalsize) {      // fin chunk!
  1608.                   //printf("chunk end at %d\n",back[i].r.size);
  1609.                   back[i].status=98;  // prochain chunk
  1610.                   if (back[i].chunk_adr!=NULL) { freet(back[i].chunk_adr); back[i].chunk_adr=NULL; } back[i].chunk_size=0;
  1611.                   retour_fread=0;       // pas d'erreur
  1612. #if CHUNKDEBUG==1
  1613.                   printf("waiting for next chunk header (soc %d)..\n",back[i].r.soc);
  1614. #endif
  1615.                 }
  1616.               }
  1617.             }
  1618.                           
  1619.             if (retour_fread < 0) {    // erreur rΘception
  1620.               back[i].status=0;    // terminΘ
  1621.               if (back[i].r.soc!=INVALID_SOCKET) {
  1622. #if HTS_DEBUG_CLOSESOCK
  1623.                 DEBUG_W("back_wait(4): deletehttp\n");
  1624. #endif
  1625.                 deletehttp(&back[i].r);
  1626.               }
  1627.               back[i].r.soc=INVALID_SOCKET;
  1628. #if CHUNKDEBUG==1
  1629.               if (back[i].is_chunk)
  1630.                 printf("must be the last chunk for %s (connection closed) - %d/%d\n",back[i].url_fil,back[i].r.size,back[i].r.totalsize);
  1631. #endif
  1632.               //if ((back[i].r.statuscode==-1) && (strnotempty(back[i].r.msg)==0)) {
  1633.               if ((back[i].r.statuscode<0) && (strnotempty(back[i].r.msg)==0)) {
  1634. #if HDEBUG
  1635.                 printf("error interruped: %s\n",back[i].r.adr);
  1636. #endif        
  1637.                 if (back[i].r.size>0)
  1638.                   strcat(back[i].r.msg,"Interrupted transfer");
  1639.                 else
  1640.                   strcat(back[i].r.msg,"No data (connection closed)");
  1641.                 back[i].r.statuscode=-4;
  1642.               }
  1643.  
  1644.               // finalize transfer
  1645.               if (back[i].r.statuscode>0) {
  1646.                 back_finalize(opt,cache,back,i);
  1647.               }
  1648.  
  1649.               if (back[i].r.totalsize>0) {    // tester totalsize
  1650.               //if ((back[i].r.totalsize>0) && (back[i].status==99)) {    // tester totalsize
  1651.                 if (back[i].r.totalsize!=back[i].r.size) {  // pas la mΩme!
  1652.                   if (!opt->tolerant) {
  1653.                     //#if HTS_CL_IS_FATAL
  1654.                     if (back[i].r.adr) freet(back[i].r.adr); back[i].r.adr=NULL;
  1655.                     if (back[i].r.size<back[i].r.totalsize)
  1656.                       back[i].r.statuscode=-4;        // recatch
  1657.                     sprintf(back[i].r.msg,"Incorrect length ("LLintP" Bytes, "LLintP" expected)",back[i].r.size,back[i].r.totalsize);
  1658.                   } else {
  1659.                     //#else
  1660.                     // Un warning suffira..
  1661.                     if (cache->errlog!=NULL) {
  1662.                       fspc(cache->errlog,"warning"); fprintf(cache->errlog,"Incorrect length ("LLintP"!="LLintP" expected) for %s%s"LF,back[i].r.size,back[i].r.totalsize,back[i].url_adr,back[i].url_fil);
  1663.                     }
  1664.                     //#endif
  1665.                   }
  1666.                 }
  1667.               }
  1668. #if BDEBUG==1
  1669.               printf("transfer ok\n");
  1670. #endif
  1671.             } else if (retour_fread > 0) {    // pas d'erreur de rΘception et data
  1672.               if (back[i].timeout>0) {    // refresh timeout si besoin est
  1673.                 back[i].timeout_refresh=time_local();
  1674.               }
  1675.  
  1676.               // Traitement des en tΩtes chunks ou en tΩtes
  1677.               if (back[i].status==98) {        // rΘception taille chunk en hexa (  aprΦs les en tΩtes, peut ne pas
  1678.                 if (back[i].chunk_size>=2) {
  1679.                   int chunk_size=-1;
  1680.                   // Ωtre prΘsent)
  1681.                   if (back[i].chunk_adr[back[i].chunk_size-1]==10) {    // LF, fin ligne chunk
  1682.                     char chunk_data[64];
  1683.                     if (back[i].chunk_size<32) {      // pas trop gros
  1684.                       back[i].chunk_adr[ back[i].chunk_size-1]='\0';    // octet nul 
  1685.                       strcpy(chunk_data,"");    // hex number
  1686.                       strcat(chunk_data,back[i].chunk_adr);
  1687. #if CHUNKDEBUG==1
  1688.                       printf("chunk received and read: %s\n",chunk_data);
  1689. #endif
  1690.                       if (back[i].r.totalsize<0)
  1691.                         back[i].r.totalsize=0;        // initialiser α 0
  1692.                       if (sscanf(chunk_data,"%x",&chunk_size) == 1) {
  1693.                         back[i].r.totalsize+=chunk_size;    // noter taille
  1694.                         back[i].r.adr=(char*) realloct(back[i].r.adr,(INTsys) back[i].r.totalsize + 1);
  1695.                         if (!back[i].r.adr) {
  1696.                           if (cache->errlog!=NULL) {
  1697.                             fprintf(cache->errlog,"Error: Not enough memory ("LLintP") for %s%s"LF,back[i].r.totalsize,back[i].url_adr,back[i].url_fil);
  1698.                           }
  1699.                         }
  1700. #if CHUNKDEBUG==1
  1701.                         printf("chunk length: %d - next total "LLintP":\n",chunk_size,back[i].r.totalsize);
  1702. #endif
  1703.                       } else                                
  1704.                         if (cache->errlog!=NULL) {
  1705.                           fprintf(cache->errlog,"Warning: Illegal chunk (%s) for %s%s"LF,back[i].chunk_adr,back[i].url_adr,back[i].url_fil);
  1706.                         }
  1707.                     } else {                                  
  1708.                       if (cache->errlog!=NULL) {
  1709.                         fprintf(cache->errlog,"Warning: Chunk too big ("LLintP") for %s%s"LF,back[i].chunk_size,back[i].url_adr,back[i].url_fil);
  1710.                       }
  1711.                     }
  1712.                     
  1713.                     // ok, continuer sur le body
  1714.                     
  1715.                     // si chunk non nul continuer (ou commencer)
  1716.                     if (chunk_size>0) {
  1717.                       back[i].status=1;     // continuer body    
  1718. #if CHUNKDEBUG==1
  1719.                       printf("waiting for body (chunk)\n");
  1720. #endif
  1721.                     } else {                // chunk nul, c'est la fin
  1722. #if CHUNKDEBUG==1
  1723.                       printf("chunk end, total: %d\n",back[i].r.size);
  1724. #endif
  1725.                       back[i].status=0;     // fin  
  1726.                       // finalize transfer
  1727.                       back_finalize(opt,cache,back,i);
  1728.                       if (back[i].r.soc!=INVALID_SOCKET) {
  1729. #if HTS_DEBUG_CLOSESOCK
  1730.                         DEBUG_W("back_wait(5): deletehttp\n");
  1731. #endif
  1732.                         deletehttp(&back[i].r); back[i].r.soc=INVALID_SOCKET;
  1733.  
  1734.                         /* Tester totalsize en fin de chunk */
  1735.                         if ((back[i].r.totalsize>0)) {    // tester totalsize
  1736.                           if (back[i].r.totalsize!=back[i].r.size) {  // pas la mΩme!
  1737. #if HTS_CL_IS_FATAL
  1738.                             if (back[i].r.adr) { freet(back[i].r.adr); back[i].r.adr=NULL; }
  1739.                             back[i].r.statuscode=-1;
  1740.                             strcpy(back[i].r.msg,"Incorrect length");
  1741. #else
  1742.                             // Un warning suffira..
  1743.                             if (cache->errlog!=NULL) {
  1744.                               fspc(cache->errlog,"warning"); fprintf(cache->errlog,"Incorrect length ("LLintP"!="LLintP" expected) for %s%s"LF,back[i].r.size,back[i].r.totalsize,back[i].url_adr,back[i].url_fil);
  1745.                             }
  1746. #endif
  1747.                           }
  1748.                         }
  1749.                         
  1750.                       
  1751.                       }
  1752.                     }
  1753.  
  1754.                     // effacer buffer (chunk en tete)
  1755.                     if (back[i].chunk_adr!=NULL) {
  1756.                       freet(back[i].chunk_adr);
  1757.                       back[i].chunk_adr=NULL;
  1758.                       back[i].chunk_size=0;
  1759.                     }
  1760.                   
  1761.                   } // chunk LF?
  1762.                 }  // taille buffer chunk>2
  1763.                 //
  1764.               } else if (back[i].status==99) {        // en tΩtes (avant le chunk si il est prΘsent)
  1765.                 //
  1766.                 if (back[i].r.size>=2) {
  1767.                   // double LF
  1768.                   if ((back[i].r.adr[back[i].r.size-1]==10) && (back[i].r.adr[back[i].r.size-2]==10)) {
  1769.                     char rcvd[2048];
  1770.                     int ptr=0;
  1771.                     
  1772. #if BDEBUG==1
  1773.                     printf("..ok, header received\n");
  1774. #endif
  1775.  
  1776.                     // ----------------------------------------
  1777.                     // traiter en-tΩte!
  1778.                     // status-line α rΘcupΘrer
  1779.                     ptr+=binput(back[i].r.adr+ptr,rcvd,2000);
  1780.                     if (strnotempty(rcvd)==0)
  1781.                       ptr+=binput(back[i].r.adr+ptr,rcvd,2000);    // "certains serveurs buggΘs envoient un \n au dΘbut" (RFC)
  1782.                     
  1783.                     // traiter status-line
  1784.                     treatfirstline(&back[i].r,rcvd);
  1785.                     
  1786. #if HDEBUG
  1787.                     printf("(Buffer) Status-Code=%d\n",back[i].r.statuscode);
  1788. #endif
  1789.                     if (_DEBUG_HEAD) {
  1790.                       if (ioinfo) {
  1791.                         fprintf(ioinfo,"response for %s%s:\r\ncode=%d\r\n",jump_identification(back[i].url_adr),back[i].url_fil,back[i].r.statuscode);
  1792.                         fprintfio(ioinfo,back[i].r.adr,">>> ");
  1793.                         fprintf(ioinfo,"\r\n");
  1794.                         fflush(ioinfo);
  1795.                       }                    // en-tΩte
  1796.                     }
  1797.                       
  1798.                     // header // ** !attention! HTTP/0.9 non supportΘ
  1799.                     do {
  1800.                       ptr+=binput(back[i].r.adr+ptr,rcvd,2000);          
  1801. #if HDEBUG
  1802.                       printf("(buffer)>%s\n",rcvd);      
  1803. #endif
  1804.                       /*
  1805.                       if (_DEBUG_HEAD) {
  1806.                         if (ioinfo) {
  1807.                           fprintf(ioinfo,"(buffer)>%s\r\n",rcvd);      
  1808.                           fflush(ioinfo);
  1809.                         }
  1810.                       }
  1811.                       */
  1812.  
  1813.                       if (strnotempty(rcvd))
  1814.                         treathead(opt->cookie,back[i].url_adr,back[i].url_fil,&back[i].r,rcvd);  // traiter
  1815.                       
  1816.                       // parfois les serveurs buggΘs renvoient un content-range avec un 200
  1817.                       if (back[i].r.statuscode==200)  // 'OK'
  1818.                         if (strfield(rcvd,"content-range:"))  // Avec un content-range: relisez les RFC..
  1819.                           back[i].r.statuscode=206;    // FORCER A 206 !!!!!
  1820.                         
  1821.                     } while(strnotempty(rcvd));
  1822.                     // ----------------------------------------                    
  1823.                     
  1824.                     // libΘrer mΘmoire  -- aprΦs! --
  1825.                     if (back[i].r.adr!=NULL) { freet(back[i].r.adr); back[i].r.adr=NULL; }
  1826.  
  1827.                     
  1828.  
  1829.  
  1830.                     /* 
  1831.                        Status code and header-response hacks
  1832.                     */
  1833.                     
  1834.                     // Check response : 203 == 200
  1835.                     if (back[i].r.statuscode==203) {  // 'Non-Authoritative Information'
  1836.                       back[i].r.statuscode=200;       // forcer "OK"
  1837.                     } else if (back[i].r.statuscode == 100) {
  1838.                       back[i].status=99;
  1839.                       back[i].r.size=0;
  1840.                       back[i].r.totalsize=0;
  1841.                       back[i].chunk_size=0;
  1842.                       back[i].r.statuscode=-1;
  1843.                       back[i].r.msg[0]='\0';
  1844.                       if ((opt->debug>1) && (opt->log!=NULL)) {
  1845.                         fspc(opt->log,"debug"); fprintf(opt->log,"Status 100 detected for %s%s, continuing headers"LF,back[i].url_adr,back[i].url_fil); test_flush;
  1846.                       }
  1847.                       continue;
  1848.                     }
  1849.                     
  1850.                     /*
  1851.                     Solve "false" 416 problems
  1852.                     */
  1853.                     if (back[i].r.statuscode==416) {  // 'Requested Range Not Satisfiable'
  1854.                       // Example:
  1855.                       // Range: bytes=2830-
  1856.                       // ->
  1857.                       // Content-Range: bytes */2830
  1858.                       if (back[i].range_req_size == back[i].r.crange) {
  1859.                         deletehttp(&back[i].r); back[i].r.soc=INVALID_SOCKET;
  1860.                         back[i].status=0;    // READY
  1861.                         back[i].r.size=back[i].r.totalsize=back[i].range_req_size;
  1862.                         filenote(back[i].url_sav,NULL);
  1863.                         back[i].r.statuscode=304;     // NOT MODIFIED
  1864.                         if ((opt->debug>1) && (opt->log!=NULL)) {
  1865.                           fspc(opt->log,"debug"); fprintf(opt->log,"File seems complete (good 416 message), breaking connection: %s%s"LF,back[i].url_adr,back[i].url_fil); test_flush;
  1866.                         }
  1867.                       }
  1868.                     }
  1869.                     
  1870.                     // Various hacks to limit re-transfers when updating a mirror
  1871.                     if (opt->sizehack) {
  1872.                       // We already have the file
  1873.                       // and ask the remote server for an update
  1874.                       // Some servers, especially dynamic pages severs, always
  1875.                       // answer that the page has been modified since last visit
  1876.                       // And answer with a 200 (OK) response, and the same page
  1877.                       // If the size is the same, and the option has been set, we assume
  1878.                       // that the file is identical - and therefore let's break the connection
  1879.                       if (back[i].is_update) {          // mise α jour
  1880.                         if (back[i].r.statuscode==200) {  // 'OK'
  1881.                           htsblk r = cache_read(opt,cache,back[i].url_adr,back[i].url_fil,NULL);    // lire entrΘe cache
  1882.                           if (r.statuscode == 200) {  // OK pas d'erreur cache
  1883.                             LLint len1,len2;
  1884.                             len1=r.totalsize;
  1885.                             len2=back[i].r.totalsize;
  1886.                             if (r.size>0)
  1887.                               len1=r.size;
  1888.                             if (len1>0) {
  1889.                               if (len1 == len2) {             // tailles identiques
  1890.                                 back[i].r.statuscode=304;     // forcer NOT MODIFIED
  1891.                                 deletehttp(&back[i].r); back[i].r.soc=INVALID_SOCKET;
  1892.                                 if ((opt->debug>1) && (opt->log!=NULL)) {
  1893.                                   fspc(opt->log,"debug"); fprintf(opt->log,"File seems complete (same size), breaking connection: %s%s"LF,back[i].url_adr,back[i].url_fil); test_flush;
  1894.                                 }
  1895.                               }
  1896.                             }
  1897.                           } else {
  1898.                             if (opt->errlog!=NULL) {
  1899.                               fspc(opt->errlog,"warning"); fprintf(opt->errlog,"File seems complete (same size), but there was a cache read error: %s%s"LF,back[i].url_adr,back[i].url_fil); test_flush;
  1900.                             }
  1901.                           }
  1902.                         }
  1903.                       }
  1904.                     }
  1905.  
  1906.                     // Various hacks to limit re-transfers when updating a mirror
  1907.                     if (opt->sizehack) {
  1908.                       // We have request for a partial file (with a 'Range: NNN-' header)
  1909.                       // and received a complete file notification (200), with 'Content-length: NNN'
  1910.                       // it might be possible that we had the complete file
  1911.                       // this is the case in *most* cases, so break the connection
  1912.                       if (back[i].r.is_write==0) {  // mode mΘmoire
  1913.                         if (back[i].r.adr==NULL) {  // rien n'a ΘtΘ Θcrit
  1914.                           if (!back[i].testmode) {  // pas mode test
  1915.                             if (strnotempty(back[i].url_sav)) {
  1916.                               if (strcmp(back[i].url_fil,"/robots.txt")) {
  1917.                                 if (back[i].r.statuscode==200) {  // 'OK'
  1918.                                   if (!is_hypertext_mime(back[i].r.contenttype)) {    // pas HTML
  1919.                                     if (back[i].r.statuscode==200) {      // "OK"
  1920.                                       if (back[i].range_req_size>0) {     // but Range: requested
  1921.                                         if (back[i].range_req_size == back[i].r.totalsize) {    // And same size
  1922. #if HTS_DEBUG_CLOSESOCK
  1923.                                           DEBUG_W("back_wait(skip_range): deletehttp\n");
  1924. #endif
  1925.                                           deletehttp(&back[i].r); back[i].r.soc=INVALID_SOCKET;
  1926.                                           back[i].status=0;    // READY
  1927.                                           back[i].r.size=back[i].r.totalsize;
  1928.                                           filenote(back[i].url_sav,NULL);
  1929.                                           back[i].r.statuscode=304;     // NOT MODIFIED
  1930.                                           if ((opt->debug>1) && (opt->log!=NULL)) {
  1931.                                             fspc(opt->log,"debug"); fprintf(opt->log,"File seems complete (reget failed), breaking connection: %s%s"LF,back[i].url_adr,back[i].url_fil); test_flush;
  1932.                                           }
  1933.                                         }
  1934.                                       }
  1935.                                     }
  1936.                                     
  1937.                                   }
  1938.                                 }
  1939.                               }
  1940.                             }
  1941.                           }
  1942.                         }
  1943.                       }
  1944.                     }
  1945.                     // END - Various hacks to limit re-transfers when updating a mirror
  1946.  
  1947.                     /* 
  1948.                     End of status code and header-response hacks
  1949.                     */
  1950.  
  1951.                     
  1952.                     
  1953.                     /* Interdiction taille par le wizard? */
  1954.                     if (back[i].r.soc!=INVALID_SOCKET) {
  1955.                       if (!back_checksize(opt,&back[i],1)) {
  1956.                         back[i].status=0;  // FINI
  1957.                         deletehttp(&back[i].r); back[i].r.soc=INVALID_SOCKET;
  1958.                         if (!back[i].testmode)
  1959.                           strcpy(back[i].r.msg,"File too big");
  1960.                         else
  1961.                           strcpy(back[i].r.msg,"Test: File too big");
  1962.                       }
  1963.                     }
  1964.                     
  1965.                     /* sinon, continuer */
  1966.                     /* if (back[i].r.soc!=INVALID_SOCKET) {   // ok rΘcupΘrer body? */
  1967.                     // head: terminΘ
  1968.                     if (back[i].head_request) {
  1969.                       if ((opt->debug>1) && (opt->log!=NULL)) {
  1970.                         fspc(opt->log,"debug"); fprintf(opt->log,"Tested file: %s%s"LF,back[i].url_adr,back[i].url_fil); test_flush;
  1971.                       }
  1972. #if HTS_DEBUG_CLOSESOCK
  1973.                       DEBUG_W("back_wait(head request): deletehttp\n");
  1974. #endif
  1975.                       // Couper connexion
  1976.                       deletehttp(&back[i].r); back[i].r.soc=INVALID_SOCKET;
  1977.                       back[i].status=0;  // terminΘ
  1978.                     }
  1979.                     // traiter une Θventuelle erreur 304 (cache α jour utilisable)
  1980.                     else if (back[i].r.statuscode==304) {  // document α jour dans le cache
  1981.                       // lire dans le cache
  1982.                       // ** NOTE: pas de vΘrif de la taille ici!!
  1983. #if HTS_DEBUG_CLOSESOCK
  1984.                       DEBUG_W("back_wait(file is not modified): deletehttp\n");
  1985. #endif
  1986.                       deletehttp(&back[i].r); back[i].r.soc=INVALID_SOCKET;
  1987.                       back[i].r=cache_read(opt,cache,back[i].url_adr,back[i].url_fil,back[i].url_sav);
  1988.                       if (!back[i].r.location)
  1989.                         back[i].r.location=back[i].location_buffer;
  1990.                       else {        /* recopier */
  1991.                         strcpy(back[i].location_buffer,back[i].r.location);
  1992.                         back[i].r.location=back[i].location_buffer;
  1993.                       }
  1994.  
  1995.                       // hack:
  1996.                       // In case of 'if-unmodified-since' hack, a 304 status can be sent
  1997.                       // then, force 'ok' status
  1998.                       if (back[i].r.statuscode == -1) {
  1999.                         if (fexist(back[i].url_sav)) {
  2000.                           back[i].r.statuscode=200;     // OK
  2001.                           if ((opt->debug>0) && (opt->log!=NULL)) {
  2002.                             fspc(opt->log,"debug"); fprintf(opt->log,"Not-modified status without cache guessed: %s%s"LF,back[i].url_adr,back[i].url_fil); test_flush;
  2003.                           }
  2004.                         }
  2005.                       }
  2006.  
  2007.                       // Status is okay?
  2008.                       if (back[i].r.statuscode!=-1) { // pas d'erreur de lecture
  2009.                         back[i].status=0;         // OK prΩt
  2010.                         back[i].r.notmodified=1;  // NON modifiΘ!
  2011.                         if ((opt->debug>0) && (opt->log!=NULL)) {
  2012.                           fspc(opt->log,"debug"); fprintf(opt->log,"File loaded after test from cache: %s%s"LF,back[i].url_adr,back[i].url_fil); test_flush;
  2013.                         }
  2014.  
  2015.                         // finalize
  2016.                         if (back[i].r.statuscode>0) {
  2017.                           back_finalize(opt,cache,back,i);
  2018.                         }
  2019.                         
  2020. #if DEBUGCA
  2021.                         printf("..document α jour aprΦs requΦte: %s%s\n",back[i].url_adr,back[i].url_fil);
  2022. #endif
  2023.                         
  2024.                         //printf(">%s status %d\n",back[p].r.contenttype,back[p].r.statuscode);
  2025.                       } else {  // erreur
  2026.                         back[i].status=0;  // terminΘ
  2027.                         //printf("erreur cache\n");
  2028.                         
  2029.                       } 
  2030.                       
  2031.                     } else if ((back[i].r.statuscode==301)
  2032.                       || (back[i].r.statuscode==302)
  2033.                       || (back[i].r.statuscode==303)
  2034.                       || (back[i].r.statuscode==307)
  2035.                       || (back[i].r.statuscode==412)
  2036.                       || (back[i].r.statuscode==416)
  2037.                       ) {   // Ne pas prendre le html, erreurs connues et gΘrΘes
  2038. #if HTS_DEBUG_CLOSESOCK
  2039.                       DEBUG_W("back_wait(301,302,303,307,412,416..): deletehttp\n");
  2040. #endif
  2041.                       // Couper connexion
  2042.                       deletehttp(&back[i].r); back[i].r.soc=INVALID_SOCKET;
  2043.                       back[i].status=0;  // terminΘ
  2044.                       // finalize
  2045.                       if (back[i].r.statuscode>0) {
  2046.                         back_finalize(opt,cache,back,i);
  2047.                       }
  2048.                     } else {    // il faut aller le chercher
  2049.                       
  2050.                       // effacer buffer (requΦte)
  2051.                       if (back[i].r.adr!=NULL) {
  2052.                         freet(back[i].r.adr);
  2053.                         back[i].r.adr=NULL;
  2054.                       }
  2055.                       back[i].r.size=0;                                 
  2056.                       
  2057.                       // traiter 206 (partial content)
  2058.                       // xxc SI CHUNK VERIFIER QUE CA MARCHE??
  2059.                       if (back[i].r.statuscode==206) {  // on nous envoie un morceau (la fin) coz une partie sur disque!
  2060.                         LLint sz=fsize(back[i].url_sav);
  2061. #if HDEBUG
  2062.                         printf("partial content: "LLintP" on disk..\n",(LLint)sz);
  2063. #endif
  2064.                         if (sz>=0) {
  2065.                           if (!is_hypertext_mime(back[i].r.contenttype)) {    // pas HTML
  2066.                             if (opt->getmode&2) {    // on peut ecrire des non html  **sinon ben euhh sera interceptΘ plus loin, donc rap sur ce qui va sortir**
  2067.                               filenote(back[i].url_sav,NULL);    // noter fichier comme connu
  2068.                               back[i].r.out=fopen(fconv(back[i].url_sav),"ab");  // append
  2069.                               if (back[i].r.out) {
  2070.                                 back[i].r.is_write=1;    // Θcrire
  2071.                                 back[i].r.size=sz;    // dΘja Θcrit
  2072.                                 back[i].r.statuscode=200;  // Forcer 'OK'
  2073.                                 if (back[i].r.totalsize>0)
  2074.                                   back[i].r.totalsize+=sz;    // plus en fait
  2075.                                 fseek(back[i].r.out,0,SEEK_END);  // α la fin
  2076. #if HDEBUG
  2077.                                 printf("continue interrupted file\n");
  2078. #endif
  2079.                               } else {    // On est dans la m**
  2080.                                 back[i].status=0;  // terminΘ (voir plus loin)
  2081.                                 strcpy(back[i].r.msg,"Can not open partial file");
  2082.                               }
  2083.                             }
  2084.                           } else {    // mΘmoire
  2085.                             FILE* fp=fopen(fconv(back[i].url_sav),"rb");
  2086.                             if (fp) {
  2087.                               LLint alloc_mem=sz + 1;
  2088.                               if (back[i].r.totalsize>0)
  2089.                                 alloc_mem+=back[i].r.totalsize;            // AJOUTER RESTANT!
  2090.                               if ( (back[i].r.adr=(char*) malloct((INTsys) alloc_mem)) ) {
  2091.                                 back[i].r.size=sz;
  2092.                                 if (back[i].r.totalsize>0)
  2093.                                   back[i].r.totalsize+=sz;    // plus en fait
  2094.                                 if (((int) fread(back[i].r.adr,1,(INTsys)sz,fp)) != sz) {
  2095.                                   back[i].status=0;  // terminΘ (voir plus loin)
  2096.                                   strcpy(back[i].r.msg,"Can not read partial file");
  2097.                                 } else {
  2098.                                   back[i].r.statuscode=200;  // Forcer 'OK'
  2099. #if HDEBUG
  2100.                                   printf("continue in mem interrupted file\n");
  2101. #endif
  2102.                                 }
  2103.                               } else {
  2104.                                 back[i].status=0;  // terminΘ (voir plus loin)
  2105.                                 strcpy(back[i].r.msg,"No memory for partial file");
  2106.                               }
  2107.                               fclose(fp);
  2108.                             } else {  // Argh.. 
  2109.                               back[i].status=0;  // terminΘ (voir plus loin)
  2110.                               strcpy(back[i].r.msg,"Can not open partial file");
  2111.                             }
  2112.                           }
  2113.                         } else {    // Non trouvΘ??
  2114.                           back[i].status=0;  // terminΘ (voir plus loin)
  2115.                           strcpy(back[i].r.msg,"Can not find partial file");
  2116.                         }
  2117.                         // Erreur?
  2118.                         if (back[i].status==0) {
  2119.                           if (back[i].r.soc!=INVALID_SOCKET) {
  2120. #if HTS_DEBUG_CLOSESOCK
  2121.                             DEBUG_W("back_wait(206 solve problems): deletehttp\n");
  2122. #endif
  2123.                             deletehttp(&back[i].r);
  2124.                           }
  2125.                           back[i].r.soc=INVALID_SOCKET;
  2126.                           //back[i].r.statuscode=206;  ????????
  2127.                           back[i].r.statuscode=-5;
  2128.                           if (strnotempty(back[i].r.msg))
  2129.                             strcpy(back[i].r.msg,"Error attempting to solve status 206 (partial file)");
  2130.                         }
  2131.                       }
  2132.                       
  2133.                       if (back[i].status!=0) {  // non terminΘ (erreur)
  2134.                         if (!back[i].testmode) {    // fichier normal
  2135.                           
  2136.                           if (!back[i].r.is_chunk) {    // pas de chunk
  2137.                             //if (back[i].r.http11!=2) {    // pas de chunk
  2138.                             back[i].is_chunk=0;
  2139.                             back[i].status=1;     // start body
  2140.                           } else {
  2141. #if CHUNKDEBUG==1
  2142.                             printf("chunk encoding detected %s..\n",back[i].url_fil);
  2143. #endif
  2144.                             back[i].is_chunk=1;
  2145.                             back[i].chunk_adr=NULL;
  2146.                             back[i].chunk_size=0;
  2147.                             back[i].status=98;    // start body wait chunk
  2148.                           }
  2149.                           if (back[i].rateout>0) {
  2150.                             back[i].rateout_time=time_local();  // refresh pour transfer rate
  2151.                           }
  2152. #if HDEBUG
  2153.                           printf("(buffer) start body!\n");
  2154. #endif
  2155.                         } else {     // mode test, ne pas passer en 1!!
  2156.                           back[i].status=0;    // READY
  2157. #if HTS_DEBUG_CLOSESOCK
  2158.                           DEBUG_W("back_wait(test ok): deletehttp\n");
  2159. #endif
  2160.                           deletehttp(&back[i].r); back[i].r.soc=INVALID_SOCKET;
  2161.                           if (back[i].r.statuscode==200) {
  2162.                             strcpy(back[i].r.msg,"Test: OK");
  2163.                             back[i].r.statuscode=-10;    // test rΘussi
  2164.                           }
  2165.                           else {    // test a ΘchouΘ, on ne change rien sauf que l'erreur est α titre indicatif
  2166.                             char tempo[1000];
  2167.                             strcpy(tempo,back[i].r.msg);
  2168.                             strcpy(back[i].r.msg,"Test: ");
  2169.                             strcat(back[i].r.msg,tempo);
  2170.                           }
  2171.                           
  2172.                         }
  2173.                       }
  2174.                       
  2175.                       } 
  2176.                       
  2177.                       /*}*/
  2178.                       
  2179.                   }  // si LF
  2180.                 }  // r.size>2
  2181.               }  // si == 99
  2182.               
  2183.             } // si pas d'erreurs
  2184. #if BDEBUG==1
  2185.             printf("bytes overall: %d\n",back[i].r.size);
  2186. #endif
  2187.           }  // donnΘes dispo
  2188.           
  2189.           // en cas d'erreur cl, supprimer Θventuel fichier sur disque
  2190. #if HTS_REMOVE_BAD_FILES
  2191.           if (back[i].status<0) {
  2192.             if (!back[i].testmode) {    // pas en test
  2193.               remove(back[i].url_sav);    // Θliminer fichier (endommagΘ)
  2194.               //printf("&& %s\n",back[i].url_sav);
  2195.             }
  2196.           }
  2197. #endif
  2198.  
  2199.           /* funny log for commandline users */
  2200.           //if (!opt->quiet) {  
  2201.           // petite animation
  2202.           if (opt->verbosedisplay==1) {
  2203.             if (back[i].status==0) {
  2204.               if (back[i].r.statuscode==200)
  2205.                 printf("* %s%s ("LLintP" bytes) - OK"VT_CLREOL"\r",back[i].url_adr,back[i].url_fil,back[i].r.size);
  2206.               else
  2207.                 printf("* %s%s ("LLintP" bytes) - %d"VT_CLREOL"\r",back[i].url_adr,back[i].url_fil,back[i].r.size,back[i].r.statuscode);
  2208.               fflush(stdout);
  2209.             }
  2210.           }
  2211.           //}
  2212.           
  2213.  
  2214.       } // status>0
  2215.     }  // for
  2216.     
  2217.     // vΘrifier timeouts
  2218.     if (gestion_timeout) {
  2219.       TStamp act;
  2220.       act=time_local();    // temps en secondes
  2221.       for(i=0;i<back_max;i++) {
  2222.         if (back[i].status>0) {  // rΘception/connexion/..
  2223.           if (back[i].timeout>0) {
  2224.             //printf("time check %d\n",((int) (act-back[i].timeout_refresh))-back[i].timeout);
  2225.             if (((int) (act-back[i].timeout_refresh))>=back[i].timeout) {
  2226.               if (back[i].r.soc!=INVALID_SOCKET) {
  2227. #if HTS_DEBUG_CLOSESOCK
  2228.                 DEBUG_W("back_wait(timeout): deletehttp\n");
  2229. #endif
  2230.                 deletehttp(&back[i].r);
  2231.               }
  2232.               back[i].r.soc=INVALID_SOCKET;
  2233.               back[i].r.statuscode=-2;
  2234.               if (back[i].status==100)
  2235.                 strcpy(back[i].r.msg,"Connect Time Out");
  2236.               else if (back[i].status==101)
  2237.                 strcpy(back[i].r.msg,"DNS Time Out");
  2238.               else
  2239.                 strcpy(back[i].r.msg,"Receive Time Out");
  2240.               back[i].status=0;  // terminΘ
  2241.             } else if ((back[i].rateout>0) && (back[i].status<99)) {
  2242.               if (((int) (act-back[i].rateout_time))>=HTS_WATCHRATE) {   // checker au bout de 15s
  2243.                 if ( (int) ((back[i].r.size)/(act-back[i].rateout_time)) < back[i].rateout ) {  // trop lent
  2244.                   back[i].status=0;  // terminΘ
  2245.                   if (back[i].r.soc!=INVALID_SOCKET) {
  2246. #if HTS_DEBUG_CLOSESOCK
  2247.                     DEBUG_W("back_wait(rateout): deletehttp\n");
  2248. #endif
  2249.                     deletehttp(&back[i].r);
  2250.                   }
  2251.                   back[i].r.soc=INVALID_SOCKET;
  2252.                   back[i].r.statuscode=-3;
  2253.                   strcpy(back[i].r.msg,"Transfer Rate Too Low");
  2254.                 }
  2255.               }
  2256.             }
  2257.           }
  2258.         }
  2259.       }
  2260.     }
  2261.     max_loop--;
  2262. #if HTS_ANALYSTE
  2263.     max_loop_chk++;
  2264. #endif
  2265.   } while((busy_state) && (busy_recv) && (max_loop>0));
  2266. #if HTS_ANALYSTE
  2267.   if ((!busy_recv) && (!busy_state)) {
  2268.     if (max_loop_chk>=1) {
  2269.       Sleep(10);    // un tite pause pour Θviter les lag..
  2270.     }
  2271.   }
  2272. #endif
  2273. }
  2274.  
  2275. int back_checksize(httrackp* opt,lien_back* eback,int check_only_totalsize) {
  2276.   LLint size_to_test;
  2277.   if (check_only_totalsize)
  2278.     size_to_test=eback->r.totalsize;
  2279.   else
  2280.     size_to_test=max(eback->r.totalsize,eback->r.size);
  2281.   if (size_to_test>=0) {
  2282.     
  2283.     /* Interdiction taille par le wizard? */
  2284.     if (hts_testlinksize(opt,eback->url_adr,eback->url_fil,(eback->r.totalsize+1023)/1024)==-1) {
  2285.       return 0;     /* interdit */
  2286.     }                     
  2287.     
  2288.     /* vΘrifier taille classique (heml et non html) */
  2289.     if ((istoobig(size_to_test,eback->maxfile_html,eback->maxfile_nonhtml,eback->r.contenttype))) {
  2290.       return 0;     /* interdit */
  2291.     }
  2292.   }
  2293.   return 1;
  2294. }
  2295.  
  2296.  
  2297. // octets transfΘrΘs + add
  2298. LLint back_transfered(LLint nb,lien_back* back,int back_max) {
  2299.   int i;
  2300.   // ajouter octets en instance
  2301.   for(i=0;i<back_max;i++)
  2302.     if ((back[i].status>0) && (back[i].status<99))
  2303.       nb+=back[i].r.size;
  2304.   return nb;      
  2305. }
  2306.  
  2307. // infos backing
  2308. // j: 1 afficher sockets 2 afficher autres 3 tout afficher
  2309. void back_info(lien_back* back,int i,int j,FILE* fp) {
  2310.   if (back[i].status>=0) {
  2311.     char s[256]; 
  2312.     s[0]='\0';
  2313.     back_infostr(back,i,j,s);
  2314.     strcat(s,LF);
  2315.     fprintf(fp,"%s",s);
  2316.   }
  2317. }
  2318.  
  2319. // infos backing
  2320. // j: 1 afficher sockets 2 afficher autres 3 tout afficher
  2321. void back_infostr(lien_back* back,int i,int j,char* s) {
  2322.   if (back[i].status>=0) {
  2323.     int aff=0;
  2324.     if (j & 1) {
  2325.       if (back[i].status==100) {
  2326.         strcat(s,"CONNECT ");
  2327.       } else if (back[i].status==99) {
  2328.         strcat(s,"INFOS ");
  2329.         aff=1;
  2330.       } else if (back[i].status==98) {
  2331.         strcat(s,"INFOSC");             // infos chunk
  2332.         aff=1;
  2333.       }
  2334.       else if (back[i].status>0) {
  2335. #if HTS_ANALYSTE==2
  2336.         strcat(s,"WAIT ");
  2337. #else
  2338.         strcat(s,"RECEIVE "); 
  2339. #endif
  2340.         aff=1; 
  2341.       }
  2342.     } 
  2343.     if (j & 2) {
  2344.       if (back[i].status==0) {
  2345.         switch (back[i].r.statuscode) {
  2346.         case 200:
  2347.           strcat(s,"READY ");
  2348.           aff=1;
  2349.           break;
  2350. #if HTS_ANALYSTE==2
  2351.         default:
  2352.           strcat(s,"ERROR ");
  2353.           break;
  2354. #else
  2355.         case -1:
  2356.           strcat(s,"ERROR ");
  2357.           aff=1;
  2358.           break;
  2359.         case -2:
  2360.           strcat(s,"TIMEOUT ");
  2361.           aff=1;
  2362.           break;
  2363.         case -3:
  2364.           strcat(s,"TOOSLOW ");
  2365.           aff=1;
  2366.           break;
  2367.         case 400:
  2368.           strcat(s,"BADREQUEST ");
  2369.           aff=1;
  2370.           break;
  2371.         case 401: case 403:
  2372.           strcat(s,"FORBIDDEN ");
  2373.           aff=1;
  2374.           break;
  2375.         case 404:
  2376.           strcat(s,"NOT FOUND ");
  2377.           aff=1;
  2378.           break;
  2379.         case 500:
  2380.           strcat(s,"SERVERROR ");
  2381.           aff=1;
  2382.           break;
  2383.         default:
  2384.           {
  2385.             char s2[256];
  2386.             sprintf(s2,"ERROR(%d)",back[i].r.statuscode);
  2387.             strcat(s,s2);
  2388.           }
  2389.           aff=1;
  2390. #endif
  2391.         }
  2392.       }
  2393.     }
  2394.     
  2395.     if (aff) {
  2396.       {
  2397.         char s2[1024];
  2398.         sprintf(s2,"\"%s",back[i].url_adr); strcat(s,s2);
  2399.         
  2400.         if (back[i].url_fil[0]!='/') strcat(s,"/");
  2401.         sprintf(s2,"%s\" ",back[i].url_fil); strcat(s,s2);
  2402.         sprintf(s,LLintP" "LLintP" ",back[i].r.size,back[i].r.totalsize); strcat(s,s2);
  2403.       }
  2404.     }
  2405.   }
  2406. }
  2407.  
  2408. // -- backing --
  2409.  
  2410. #undef test_flush
  2411.